Attachment #170446 for bug #208916




#!/bin/sh
# $FreeBSD$
#
# MAINTAINER: portmgr@FreeBSD.org

set -e

. "${dp_SCRIPTSDIR}/functions.sh"

validate_env dp_ECHO_MSG dp_PKG_BIN dp_PORTNAME

set -u

# If the package is pkg, disable these checks, it fails while
# upgrading when pkg is not there.
# FIXME: check is this is still true
if [ "${dp_PORTNAME}" = "pkg" ]; then
	exit 0
fi

if [ -x "${dp_PKG_BIN}" ]; then
	vlist=$(${dp_PKG_BIN} audit "${dp_PKGNAME}" || :)
	if [ "${vlist}" = "0 problem(s) in the installed packages found." ]; then
		vlist=""
	fi
fi

if [ -n "$vlist" ]; then
	${dp_ECHO_MSG} "===>  ${dp_PKGNAME} has known vulnerabilities:"
	${dp_ECHO_MSG} "$vlist"
	${dp_ECHO_MSG} "=> Please update your ports tree and try again."
	${dp_ECHO_MSG} "=> Note: Vulnerable ports are marked as such even if there is no update available."
	${dp_ECHO_MSG} "=> If you wish to ignore this vulnerability rebuild with 'make DISABLE_VULNERABILITIES=yes'"
	exit 1
fi




#!/bin/sh
# $FreeBSD$
#
# MAINTAINER: portmgr@FreeBSD.org

set -e

. "${dp_SCRIPTSDIR}/functions.sh"

validate_env dp_CHECKSUM_ALGORITHMS dp_CURDIR dp_DISTDIR dp_DISTINFO_FILE \
	dp_DIST_SUBDIR dp_ECHO_MSG dp_FETCH_REGET dp_MAKE dp_MAKEFLAGS \
	dp_DISABLE_SIZE dp_NO_CHECKSUM

set -u

check_checksum_algorithms

if [ -f "${dp_DISTINFO_FILE}" ]; then
	cd "${dp_DISTDIR}"
	OK=
	refetchlist=
	for file in "${@}"; do
		ignored="true"
		for alg in ${dp_CHECKSUM_ALGORITHMS}; do
			ignore="false"
			eval "alg_executable=\$dp_${alg}"

			if [ "$alg_executable" != "NO" ]; then
				MKSUM=$(eval $alg_executable \< "${file}")
				CKSUM=$(distinfo_data "${alg}" "${file}")
			else
				ignore="true"
			fi

			if [ $ignore = "false" -a -z "$CKSUM" ]; then
				${dp_ECHO_MSG} "=> No $alg checksum recorded for $file."
				ignore="true"
			fi

			if [ $ignore = "false" ]; then
				match="false"
				for chksum in $CKSUM; do
					if [ "$chksum" = "$MKSUM" ]; then
						match="true"
						break
					fi
				done
				if [ $match = "true" ]; then
					${dp_ECHO_MSG} "=> $alg Checksum OK for $file."
					ignored="false"
				else
					${dp_ECHO_MSG} "=> $alg Checksum mismatch for $file."
					refetchlist="$refetchlist $file "
					OK="${OK:-retry}"
					[ "${OK}" = "retry" -a "${dp_FETCH_REGET}" -gt 0 ] && rm -f "${file}"
					ignored="false"
				fi
			fi
		done

		if [ $ignored = "true" ]; then
			${dp_ECHO_MSG} "=> No suitable checksum found for $file."
			OK=false
		fi
	done

	if [ "${OK:=true}" = "retry" ] && [ "${dp_FETCH_REGET}" -gt 0 ]; then
		${dp_ECHO_MSG} "===>  Refetch for ${dp_FETCH_REGET} more times files: $refetchlist"
		if ${dp_MAKE} -C "${dp_CURDIR}" ${dp_MAKEFLAGS} FORCE_FETCH_LIST="$refetchlist" FETCH_REGET="$((dp_FETCH_REGET - 1))" fetch; then
			if ${dp_MAKE} -C "${dp_CURDIR}" ${dp_MAKEFLAGS} FETCH_REGET="$((dp_FETCH_REGET - 1))" checksum ; then
			OK="true"
			fi
		fi
	fi

	if [ "$OK" != "true" -a "${dp_FETCH_REGET}" -eq 0 ]; then
		${dp_ECHO_MSG} "===>  Giving up on fetching files: $refetchlist"
		${dp_ECHO_MSG} "Make sure the Makefile and distinfo file (${dp_DISTINFO_FILE})"
		${dp_ECHO_MSG} "are up to date.  If you are absolutely sure you want to override this"
		${dp_ECHO_MSG} "check, type \"make NO_CHECKSUM=yes [other args]\"."
		exit 1
	fi
	if [ "$OK" != "true" ]; then
		exit 1
	fi
elif [ -n "${@}" ]; then
	${dp_ECHO_MSG} "=> No checksum file (${DISTINFO_FILE})."
	exit 1
fi




#!/bin/sh
# $FreeBSD$
#
# MAINTAINER: portmgr@FreeBSD.org

set -e

. "${dp_SCRIPTSDIR}/functions.sh"

validate_env dp_DEVELOPER dp_DISABLE_SIZE dp_DISTDIR dp_DISTINFO_FILE \
	dp_DIST_SUBDIR dp_ECHO_MSG dp_FETCH_AFTER_ARGS dp_FETCH_BEFORE_ARGS \
	dp_FETCH_CMD dp_FETCH_ENV dp_FORCE_FETCH_ALL dp_FORCE_FETCH_LIST \
	dp_MASTER_SITE_BACKUP dp_MASTER_SITE_OVERRIDE dp_MASTER_SORT_AWK \
	dp_NO_CHECKSUM dp_RANDOMIZE_SITES dp_SITE_FLAVOR dp_SCRIPTSDIR \
	dp_SORTED_MASTER_SITES_DEFAULT_CMD dp_SORTED_PATCH_SITES_DEFAULT_CMD \
	dp_TARGET

set -u

mkdir -p "${dp_DISTDIR}"
cd "${dp_DISTDIR}"

for _file in "${@}"; do
	file=${_file%%:*}

	# If this files has groups
	if [ "$_file" = "$file" ]; then
		select=''
	else
		select=$(echo "${_file##*:}" | sed -e 's/,/ /g')
	fi

	filebasename=${file##*/}
	if [ -n "${dp_FORCE_FETCH_ALL}" ]; then
		force_fetch=true
	else
		force_fetch=false
		for afile in ${dp_FORCE_FETCH_LIST}; do
			afile=${afile##*/}
			if [ "x$afile" = "x$filebasename" ]; then
				force_fetch=true
			fi
		done
	fi
	if [ ! -f "$file" -a ! -f "$filebasename" -o "$force_fetch" = "true" ]; then
		full_file="${dp_DIST_SUBDIR:+${dp_DIST_SUBDIR}/}${file}"
		if [ -L "$file" -o -L "$filebasename" ]; then
			${dp_ECHO_MSG} "=> ${dp_DISTDIR}/$file is a broken symlink."
			${dp_ECHO_MSG} "=> Perhaps a filesystem (most likely a CD) isn't mounted?"
			${dp_ECHO_MSG} "=> Please correct this problem and try again."
			exit 1
		fi
		if [ -f "${dp_DISTINFO_FILE}" -a -z "${dp_NO_CHECKSUM}" ]; then
			_sha256sum=$(distinfo_data SHA256 "${full_file}")
			if [ -z "$_sha256sum" ]; then
				${dp_ECHO_MSG} "=> ${dp_DIST_SUBDIR:+$dp_DIST_SUBDIR/}$file is not in ${dp_DISTINFO_FILE}."
				${dp_ECHO_MSG} "=> Either ${dp_DISTINFO_FILE} is out of date, or"
				${dp_ECHO_MSG} "=> ${dp_DIST_SUBDIR:+$dp_DIST_SUBDIR/}$file is spelled incorrectly."
				exit 1
			fi
		fi
		case ${dp_TARGET} in
		do-fetch|makesum)
			${dp_ECHO_MSG} "=> $file doesn't seem to exist in ${dp_DISTDIR}."
			;;
		esac
		if [ ! -w "${dp_DISTDIR}" ]; then
			${dp_ECHO_MSG} "=> ${dp_DISTDIR} is not writable by you; cannot fetch."
			exit 1
		fi
		if [ -n "$select" ] ; then
			__MASTER_SITES_TMP=
			for group in $select; do
				# Disable nounset for this, it may come up empty.
				set +u
				eval ___MASTER_SITES_TMP="\${_${dp_SITE_FLAVOR}_SITES_${group}}"
				set -u
				if [ -n "${___MASTER_SITES_TMP}" ] ; then
					__MASTER_SITES_TMP="${__MASTER_SITES_TMP} ${___MASTER_SITES_TMP}"
				else
					case ${dp_TARGET} in
					do-fetch|makesum)
						if [ -n "${dp_DEVELOPER}" ]; then
							${dp_ECHO_MSG} "===> /!\\ Error /!\\"
						else
							${dp_ECHO_MSG} "===> /!\\ Warning /!\\"
						fi
						${dp_ECHO_MSG} "     The :${group} group used for $file is missing"
						${dp_ECHO_MSG} "     from ${dp_SITE_FLAVOR}_SITES. Check for typos, or errors."
						if [ -n "${dp_DEVELOPER}" ]; then
							exit 1
						fi
						;;
					esac

				fi
			done
			___MASTER_SITES_TMP=
			SORTED_MASTER_SITES_CMD_TMP="echo ${dp_MASTER_SITE_OVERRIDE} $(echo -n "${__MASTER_SITES_TMP}" | awk "${dp_MASTER_SORT_AWK}") ${dp_MASTER_SITE_BACKUP}"
		else
			if [ ${dp_SITE_FLAVOR} = "MASTER" ]; then
				SORTED_MASTER_SITES_CMD_TMP="${dp_SORTED_MASTER_SITES_DEFAULT_CMD}"
			else
				SORTED_MASTER_SITES_CMD_TMP="${dp_SORTED_PATCH_SITES_DEFAULT_CMD}"
			fi
		fi
		case ${dp_TARGET} in
			fetch-list)
				echo -n "mkdir -p ${dp_DISTDIR} && "
				echo -n "cd ${dp_DISTDIR} && { "
				;;
		esac
		sites_remaining=0
		sites="$(eval "${SORTED_MASTER_SITES_CMD_TMP} ${dp_RANDOMIZE_SITES}")"
		for site in ${sites}; do
			sites_remaining=$((sites_remaining + 1))
		done
		for site in ${sites}; do
			sites_remaining=$((sites_remaining - 1))
			CKSIZE=$(distinfo_data SIZE "${full_file}")
			# The site may contain special shell characters, they
			# need to be escaped.
			site=$(echo "${site}" | sed -e 's/[&;()#]/\\&/g')
			# There is a lot of escaping, but the " needs to survive echo/eval.
			case ${file} in
				*/*)
					mkdir -p "${file%/*}"
					args="-o \\\"${file}\\\" \\\"${site}${file}\\\""
					;;
				*)
					args="\\\"${site}${file}\\\""
					;;
			esac
			_fetch_cmd=$(eval "echo ${dp_FETCH_ENV} ${dp_FETCH_CMD} ${dp_FETCH_BEFORE_ARGS} ${args} ${dp_FETCH_AFTER_ARGS}")
			case ${dp_TARGET} in
			do-fetch|makesum)
				${dp_ECHO_MSG} "=> Attempting to fetch ${site}${file}"
				if eval "env ${_fetch_cmd}"; then
					actual_size=$(eval stat -f %z "${file}")
					if [ -n "${dp_DISABLE_SIZE}" ] || [ -z "${CKSIZE}" ] || [ "${actual_size}" -eq "${CKSIZE}" ]; then
						continue 2
					else
						${dp_ECHO_MSG} "=> Fetched file size mismatch (expected ${CKSIZE}, actual ${actual_size})"
						if [ ${sites_remaining} -gt 0 ]; then
							${dp_ECHO_MSG} "=> Trying next site"
							rm -f "${file}"
						fi
					fi
				fi
				;;
			fetch-list)
				echo -n "env ${_fetch_cmd} || "
				;;
			fetch-url-list-int)
				eval "echo $(eval "echo ${args}")"
				;;
			esac
		done
		case ${dp_TARGET} in
		do-fetch|makesum)
			${dp_ECHO_MSG} "=> Couldn't fetch it - please try to retrieve this"
			${dp_ECHO_MSG} "=> port manually into ${dp_DISTDIR} and try again."
			exit 1
			;;
		fetch-list)
			echo "echo ${file} not fetched; }" ; \
			;;
		esac
	fi
done





		fi
	done
}

distinfo_data() {
	local alg file

	alg=$1
	file=$2

	if [ \( -n "${dp_DISABLE_SIZE}" -a -n "${dp_NO_CHECKSUM}" \) -o ! -f "${dp_DISTINFO_FILE}" ]; then
		exit
	fi
	awk -v alg="$alg" -v file="${file}" \
		'$1 == alg && $2 == "(" file ")" {print $4}' "${dp_DISTINFO_FILE}"
}

check_checksum_algorithms() {
	for alg in ${dp_CHECKSUM_ALGORITHMS}; do
		eval "alg_executable=\$dp_$alg"
		if [ -z "$alg_executable" ]; then
			${dp_ECHO_MSG} "Checksum algorithm $alg: Couldn't find the executable."
			${dp_ECHO_MSG} "Set $alg=/path/to/$alg in /etc/make.conf and try again."
			exit 1
		elif [ ! -x "$alg_executable" ]; then
			${dp_ECHO_MSG} "Checksum algorithm $alg: $alg_executable is not executable."
			${dp_ECHO_MSG} "Fix modes, or change $alg=$alg_executable in /etc/make.conf and try again."
			exit 1
		fi
	done
}




#!/bin/sh
# $FreeBSD$
#
# MAINTAINER: portmgr@FreeBSD.org

set -e

. "${dp_SCRIPTSDIR}/functions.sh"

validate_env dp_CHECKSUM_ALGORITHMS dp_CKSUMFILES dp_DISTDIR dp_DISTINFO_FILE \
	dp_ECHO_MSG

set -u

DISTINFO_OLD=$(mktemp -t makesum-old)
DISTINFO_NEW=$(mktemp -t makesum-new)

trap 'rm -f ${DISTINFO_OLD} ${DISTINFO_NEW}' EXIT INT TERM

check_checksum_algorithms

cd "${dp_DISTDIR}"

# Running `make makesum` a twice should not change the timestamp generated from
# the first run.
# So, we extract the content of the distinfo file minus the TIMESTAMP, if it
# contains a TIMESTAMP.
if [ -f "${dp_DISTINFO_FILE}" ] && grep -q "^TIMESTAMP " ${dp_DISTINFO_FILE}; then
	grep -v "^TIMESTAMP " ${dp_DISTINFO_FILE} > ${DISTINFO_OLD}
fi

for file in ${dp_CKSUMFILES}; do
	for alg in ${dp_CHECKSUM_ALGORITHMS}; do
		eval "alg_executable=\$dp_$alg"

		if [ "$alg_executable" != "NO" ]; then
			$alg_executable "$file" >> "${DISTINFO_NEW}"
		fi
	done
	echo "SIZE ($file) = $(stat -f %z "$file")" >> "${DISTINFO_NEW}"
done

# Now, we generate the distinfo file in two cases:
# - If the saved file is empty, it means there was no TIMESTAMP in it, so we
#   need to add one.
# - If the old and new distinfo content minus the TIMESTAMP differ, it means
#   something was updated or changed, it is time to generate a new timestamp.
if [ ! -s ${DISTINFO_OLD} ] || ! cmp -s ${DISTINFO_OLD} ${DISTINFO_NEW}; then
	echo "TIMESTAMP = $(date '+%s')" > ${dp_DISTINFO_FILE}
	cat ${DISTINFO_NEW} >> ${dp_DISTINFO_FILE}
fi




AUDITFILE?=		${PKG_DBDIR}/vuln.xml

check-vulnerable:
.if !defined(DISABLE_VULNERABILITIES) && !defined(PACKAGE_BUILDING) \
		&& exists(${AUDITFILE})
	@${SETENV} \
			dp_ECHO_MSG="${ECHO_MSG}" \
			dp_PKG_BIN="${PKG_BIN}" \
			dp_PORTNAME="${PORTNAME}" \
			dp_SCRIPTSDIR="${SCRIPTSDIR}" \
			${SH} ${SCRIPTSDIR}/check-vulnerable.sh
.endif

# Quote simply quote all variables, except FETCH_ENV, some ports are creative
# with it, and it needs to be quoted twice to pass through the echo/eval in
# do-fetch.
_DO_FETCH_ENV= \
			dp_DISABLE_SIZE='${DISABLE_SIZE}' \
			dp_DISTDIR='${_DISTDIR}' \
			dp_DISTINFO_FILE='${DISTINFO_FILE}' \
			dp_DIST_SUBDIR='${DIST_SUBDIR}' \
			dp_ECHO_MSG='${ECHO_MSG}' \
			dp_FETCH_AFTER_ARGS='${FETCH_AFTER_ARGS}' \
			dp_FETCH_BEFORE_ARGS='${FETCH_BEFORE_ARGS}' \
			dp_FETCH_CMD='${FETCH_CMD}' \
			dp_FETCH_ENV=${FETCH_ENV:Q:Q} \
			dp_FORCE_FETCH_ALL='${FORCE_FETCH_ALL}' \
			dp_FORCE_FETCH_LIST='${FORCE_FETCH_LIST}' \
			dp_MASTER_SITE_BACKUP='${_MASTER_SITE_BACKUP}' \
			dp_MASTER_SITE_OVERRIDE='${_MASTER_SITE_OVERRIDE}' \
			dp_MASTER_SORT_AWK='${MASTER_SORT_AWK}' \
			dp_NO_CHECKSUM='${NO_CHECKSUM}' \
			dp_RANDOMIZE_SITES='${_RANDOMIZE_SITES}' \
			dp_SCRIPTSDIR='${SCRIPTSDIR}' \
			dp_SORTED_MASTER_SITES_DEFAULT_CMD='${SORTED_MASTER_SITES_DEFAULT_CMD}' \
			dp_SORTED_PATCH_SITES_DEFAULT_CMD='${SORTED_PATCH_SITES_DEFAULT_CMD}' \
			dp_TARGET='${.TARGET}'
.if defined(DEVELOPER)
_DO_FETCH_ENV+= dp_DEVELOPER=yes
.else
_DO_FETCH_ENV+= dp_DEVELOPER=
.endif

# set alg to any of SIZE, SHA256 (or any other checksum algorithm):
DISTINFO_DATA?=	if [ \( -n "${DISABLE_SIZE}" -a -n "${NO_CHECKSUM}" \) -o ! -f "${DISTINFO_FILE}" ]; then exit; fi; \
	DIR=${DIST_SUBDIR}; ${AWK} -v alg=$$alg -v file=$${DIR:+$$DIR/}$${file}	\
		'$$1 == alg && $$2 == "(" file ")" {print $$4}' ${DISTINFO_FILE}

# Fetch

.if !target(do-fetch)
do-fetch:
.if !empty(DISTFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_MASTER_SITES_ENV} \
			dp_SITE_FLAVOR=MASTER \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${DISTFILES:C/.*/'&'/}
.endif
.if defined(PATCHFILES) && !empty(PATCHFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_PATCH_SITES_ENV} \
			dp_SITE_FLAVOR=PATCH \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${PATCHFILES:C/.*/'&'/}
.endif
.endif
#
# Prints out a list of files to fetch (useful to do a batch fetch)

.if !target(fetch-list)
fetch-list:
.if !empty(DISTFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_MASTER_SITES_ENV} \
			dp_SITE_FLAVOR=MASTER \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${DISTFILES:C/.*/'&'/}
.endif
.if defined(PATCHFILES) && !empty(PATCHFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_PATCH_SITES_ENV} \
			dp_SITE_FLAVOR=PATCH \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${PATCHFILES:C/.*/'&'/}
					${ECHO_MSG} "=> Either ${DISTINFO_FILE} is out of date, or"; \
					${ECHO_MSG} "=> $${DIR:+$$DIR/}$$file is spelled incorrectly."; \
					exit 1; \
				fi; \
			fi; \
			${ECHO_MSG} "=> $$file doesn't seem to exist in ${_DISTDIR}."; \
			if [ ! -w ${_DISTDIR} ]; then \
			   ${ECHO_MSG} "=> ${_DISTDIR} is not writable by you; cannot fetch."; \
			   exit 1; \
			fi; \
			if [ ! -z "$$select" ] ; then \
				__MASTER_SITES_TMP= ; \
				for group in $$select; do \
					if [ ! -z \$${_MASTER_SITES_$${group}} ] ; then \
						eval ___MASTER_SITES_TMP="\$${_MASTER_SITES_$${group}}" ; \
						__MASTER_SITES_TMP="$${__MASTER_SITES_TMP} $${___MASTER_SITES_TMP}" ; \
					fi; \
				done; \
				___MASTER_SITES_TMP= ; \
				SORTED_MASTER_SITES_CMD_TMP="${ECHO_CMD} ${_MASTER_SITE_OVERRIDE} `${ECHO_CMD} $${__MASTER_SITES_TMP} | ${AWK} '${MASTER_SORT_AWK:S|\\|\\\\|g}'` ${_MASTER_SITE_BACKUP}" ; \
			else \
				SORTED_MASTER_SITES_CMD_TMP="${SORTED_MASTER_SITES_DEFAULT_CMD}" ; \
			fi; \
			sites_remaining=0; \
			sites="`eval $$SORTED_MASTER_SITES_CMD_TMP ${_RANDOMIZE_SITES}`"; \
			for site in $${sites}; do \
				sites_remaining=$$(($${sites_remaining} + 1)); \
			done; \
			for site in $${sites}; do \
				sites_remaining=$$(($${sites_remaining} - 1)); \
			    ${ECHO_MSG} "=> Attempting to fetch $${site}$${file}"; \
				CKSIZE=`alg=SIZE; ${DISTINFO_DATA}`; \
				case $${file} in \
				*/*)	${MKDIR} $${file%/*}; \
						args="-o $${file} $${site}$${file}";; \
				*)		args=$${site}$${file};; \
				esac; \
				if ${SETENV} ${FETCH_ENV} ${FETCH_CMD} ${FETCH_BEFORE_ARGS} $${args} ${FETCH_AFTER_ARGS}; then \
					actual_size=`stat -f %z "$${file}"`; \
					if [ -n "${DISABLE_SIZE}" ] || [ -z "$${CKSIZE}" ] || [ $${actual_size} -eq $${CKSIZE} ]; then \
						continue 2; \
					else \
						${ECHO_MSG} "=> Fetched file size mismatch (expected $${CKSIZE}, actual $${actual_size})"; \
						if [ $${sites_remaining} -gt 0 ]; then \
							${ECHO_MSG} "=> Trying next site"; \
							${RM} -f $${file}; \
						fi; \
					fi; \
				fi; \
			done; \
			${ECHO_MSG} "=> Couldn't fetch it - please try to retrieve this";\
			${ECHO_MSG} "=> port manually into ${_DISTDIR} and try again."; \
			exit 1; \
	    fi; \
	 done
.if defined(PATCHFILES)
	@cd ${_DISTDIR};\
	${_PATCH_SITES_ENV} ; \
	for _file in ${PATCHFILES}; do \
		file=`${ECHO_CMD} $$_file | ${SED} -E -e 's/:[^-:][^:]*$$//'` ; \
		if [ $$_file = $$file ]; then	\
			select='';	\
		else	\
			select=`${ECHO_CMD} $${_file##*:} | ${SED} -e 's/,/ /g'` ;	\
		fi;	\
		file=`${ECHO_CMD} $$file | ${SED} -E -e 's/:-[^:]+$$//'` ; \
		force_fetch=false; \
		filebasename=$${file##*/}; \
		for afile in ${FORCE_FETCH}; do \
			afile=$${afile##*/}; \
			if [ "x$$afile" = "x$$filebasename" ]; then \
				force_fetch=true; \
			fi; \
		done; \
		if [ ! -f $$file -a ! -f $$filebasename -o "$$force_fetch" = "true" ]; then \
			if [ -L $$file -o -L $${file##*/} ]; then \
				${ECHO_MSG} "=> ${_DISTDIR}/$$file is a broken symlink."; \
				${ECHO_MSG} "=> Perhaps a filesystem (most likely a CD) isn't mounted?"; \
				${ECHO_MSG} "=> Please correct this problem and try again."; \
				exit 1; \
			fi; \
			${ECHO_MSG} "=> $$file doesn't seem to exist in ${_DISTDIR}."; \
			if [ ! -z "$$select" ] ; then \
				__PATCH_SITES_TMP= ; \
				for group in $$select; do \
					if [ ! -z \$${_PATCH_SITES_$${group}} ] ; then \
						eval ___PATCH_SITES_TMP="\$${_PATCH_SITES_$${group}}" ; \
						__PATCH_SITES_TMP="$${__PATCH_SITES_TMP} $${___PATCH_SITES_TMP}" ; \
					fi; \
				done; \
				___PATCH_SITES_TMP= ; \
				SORTED_PATCH_SITES_CMD_TMP="${ECHO_CMD} ${_MASTER_SITE_OVERRIDE} `${ECHO_CMD} $${__PATCH_SITES_TMP} | ${AWK} '${MASTER_SORT_AWK:S|\\|\\\\|g}'` ${_MASTER_SITE_BACKUP}" ; \
			else \
				SORTED_PATCH_SITES_CMD_TMP="${SORTED_PATCH_SITES_DEFAULT_CMD}" ; \
			fi; \
			sites_remaining=0; \
			sites="`eval $$SORTED_PATCH_SITES_CMD_TMP`"; \
			for site in $${sites}; do \
				sites_remaining=$$(($${sites_remaining} + 1)); \
			done; \
			for site in $${sites}; do \
				sites_remaining=$$(($${sites_remaining} - 1)); \
			    ${ECHO_MSG} "=> Attempting to fetch $${site}$${file}"; \
				CKSIZE=`alg=SIZE; ${DISTINFO_DATA}`; \
				case $${file} in \
				*/*)	${MKDIR} $${file%/*}; \
						args="-o $${file} $${site}$${file}";; \
				*)		args=$${site}$${file};; \
				esac; \
				if ${SETENV} ${FETCH_ENV} ${FETCH_CMD} ${FETCH_BEFORE_ARGS} $${args} ${FETCH_AFTER_ARGS}; then \
					actual_size=`stat -f %z "$${file}"`; \
					if [ -n "${DISABLE_SIZE}" ] || [ -z "$${CKSIZE}" ] || [ $${actual_size} -eq $${CKSIZE} ]; then \
						continue 2; \
					else \
						${ECHO_MSG} "=> Fetched file size mismatch (expected $${CKSIZE}, actual $${actual_size})"; \
						if [ $${sites_remaining} -gt 1 ]; then \
							${ECHO_MSG} "=> Trying next site"; \
							${RM} -f $${file}; \
						fi; \
					fi; \
				fi; \
			done; \
			${ECHO_MSG} "=> Couldn't fetch it - please try to retrieve this";\
			${ECHO_MSG} "=> port manually into ${_DISTDIR} and try again."; \
			exit 1; \
		fi; \
	 done
.endif
.endif

# Used by fetch-urlall-list and fetch-url-list

.if !target(fetch-url-list-int)
fetch-url-list-int:
.if !empty(DISTFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_MASTER_SITES_ENV} \
			dp_SITE_FLAVOR=MASTER \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${DISTFILES:C/.*/'&'/}
.endif
.if defined(PATCHFILES) && !empty(PATCHFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_PATCH_SITES_ENV} \
			dp_SITE_FLAVOR=PATCH \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${PATCHFILES:C/.*/'&'/}
.endif
.endif

# Prints out all the URL for all the DISTFILES and PATCHFILES.

.if !target(fetch-urlall-list)
fetch-urlall-list:
	@cd ${.CURDIR} && ${SETENV} FORCE_FETCH_ALL=yes ${MAKE} fetch-url-list-int
.endif

# Prints the URL for all the DISTFILES and PATCHFILES that are not here

.if !target(fetch-url-list)
fetch-url-list: fetch-url-list-int
.endif


# Extract

clean-wrkdir:

.endif
.endif

# Prints out a list of files to fetch (useful to do a batch fetch)

.if !target(fetch-list)
fetch-list:
	@${MKDIR} ${_DISTDIR}
	@(cd ${_DISTDIR}; \
	 ${_MASTER_SITES_ENV} ; \
	 for _file in ${DISTFILES}; do \
		file=`${ECHO_CMD} $$_file | ${SED} -E -e 's/:[^:]+$$//'` ; \
		if [ $$_file = $$file ]; then	\
			select='';	\
		else	\
			select=`${ECHO_CMD} $${_file##*:} | ${SED} -e 's/,/ /g'` ;	\
		fi;	\
		if [ ! -f $$file -a ! -f $${file##*/} ]; then \
			if [ ! -z "$$select" ] ; then \
				__MASTER_SITES_TMP= ; \
				for group in $$select; do \
					if [ ! -z \$${_MASTER_SITES_$${group}} ] ; then \
						eval ___MASTER_SITES_TMP=\$${_MASTER_SITES_$${group}} ; \
						__MASTER_SITES_TMP="$${__MASTER_SITES_TMP} $${___MASTER_SITES_TMP}" ; \
					fi; \
				done; \
				___MASTER_SITES_TMP= ; \
				SORTED_MASTER_SITES_CMD_TMP="${ECHO_CMD} ${_MASTER_SITE_OVERRIDE} `${ECHO_CMD} $${__MASTER_SITES_TMP} | ${AWK} '${MASTER_SORT_AWK:S|\\|\\\\|g}'` ${_MASTER_SITE_BACKUP}" ; \
			else \
				SORTED_MASTER_SITES_CMD_TMP="${SORTED_MASTER_SITES_DEFAULT_CMD}" ; \
			fi; \
			${ECHO_CMD} -n ${MKDIR} ${_DISTDIR} '&& ' ; \
			${ECHO_CMD} -n cd ${_DISTDIR} '&& { ' ; \
			for site in `eval $$SORTED_MASTER_SITES_CMD_TMP ${_RANDOMIZE_SITES}`; do \
				if [ ! -z "`${ECHO_CMD} ${NOFETCHFILES} | ${GREP} -w $${file}`" ]; then \
					if [ -z "`${ECHO_CMD} ${MASTER_SITE_OVERRIDE} | ${GREP} -w $${site}`" ]; then \
						continue; \
					fi; \
				fi; \
				CKSIZE=`alg=SIZE; ${DISTINFO_DATA}`; \
				case $${file} in \
				*/*)	args="-o $${file} $${site}$${file}";; \
				*)		args=$${site}$${file};; \
				esac; \
				${ECHO_CMD} -n ${SETENV} ${FETCH_ENV} ${FETCH_CMD} ${FETCH_BEFORE_ARGS} $${args} "${FETCH_AFTER_ARGS}" '|| ' ; \
			done; \
			${ECHO_CMD} "${ECHO_CMD} $${file} not fetched; }" ; \
		fi; \
	done)
.if defined(PATCHFILES)
	@(cd ${_DISTDIR}; \
	 ${_PATCH_SITES_ENV} ; \
	 for _file in ${PATCHFILES}; do \
		file=`${ECHO_CMD} $$_file | ${SED} -E -e 's/:[^-:][^:]*$$//'` ; \
		if [ $$_file = $$file ]; then	\
			select='';	\
		else	\
			select=`${ECHO_CMD} $${_file##*:} | ${SED} -e 's/,/ /g'` ;	\
		fi;	\
		file=`${ECHO_CMD} $$file | ${SED} -E -e 's/:-[^:]+$$//'` ; \
		if [ ! -f $$file -a ! -f $${file##*/} ]; then \
			if [ ! -z "$$select" ] ; then \
				__PATCH_SITES_TMP= ; \
				for group in $$select; do \
					if [ ! -z \$${_PATCH_SITES_$${group}} ] ; then \
						eval ___PATCH_SITES_TMP=\$${_PATCH_SITES_$${group}} ; \
						__PATCH_SITES_TMP="$${__PATCH_SITES_TMP} $${___PATCH_SITES_TMP}" ; \
				fi; \
				done; \
				___PATCH_SITES_TMP= ; \
				SORTED_PATCH_SITES_CMD_TMP="${ECHO_CMD} ${_MASTER_SITE_OVERRIDE} `${ECHO_CMD} $${__PATCH_SITES_TMP} | ${AWK} '${MASTER_SORT_AWK:S|\\|\\\\|g}'` ${_MASTER_SITE_BACKUP}" ; \
			else \
				SORTED_PATCH_SITES_CMD_TMP="${SORTED_PATCH_SITES_DEFAULT_CMD}" ; \
			fi; \
			${ECHO_CMD} -n ${MKDIR} ${_DISTDIR} '&& ' ; \
			${ECHO_CMD} -n cd ${_DISTDIR} '&& { ' ; \
			for site in `eval $$SORTED_PATCH_SITES_CMD_TMP ${_RANDOMIZE_SITES}`; do \
				CKSIZE=`alg=SIZE; ${DISTINFO_DATA}`; \
				case $${file} in \
				*/*)	args="-o $${file} $${site}$${file}";; \
				*)		args=$${site}$${file};; \
				esac; \
				${ECHO_CMD} -n ${SETENV} ${FETCH_ENV} ${FETCH_CMD} ${FETCH_BEFORE_ARGS} $${args} "${FETCH_AFTER_ARGS}" '|| ' ; \
			done; \
			${ECHO_CMD} "${ECHO_CMD} $${file} not fetched; }" ; \
		fi; \
	 done)
.endif
.endif

.if !target(fetch-url-list-int)
fetch-url-list-int:
	@${MKDIR} ${_DISTDIR}
	@(cd ${_DISTDIR}; \
	${_MASTER_SITES_ENV}; \
	for _file in ${DISTFILES}; do \
		file=`${ECHO_CMD} $$_file | ${SED} -E -e 's/:[^:]+$$//'` ; \
			fileptn=`${ECHO_CMD} $$file | ${SED} 's|/|\\\\/|g;s/\./\\\\./g;s/\+/\\\\+/g;s/\?/\\\\?/g'` ; \
		if [ $$_file = $$file ]; then	\
			select='';	\
		else	\
			select=`${ECHO_CMD} $${_file##*:} | ${SED} -e 's/,/ /g'` ;	\
		fi;	\
		if [ ! -z "${LISTALL}" -o ! -f $$file -a ! -f $${file##*/} ]; then \
			if [ ! -z "$$select" ] ; then \
				__MASTER_SITES_TMP= ; \
				for group in $$select; do \
					if [ ! -z \$${_MASTER_SITES_$${group}} ] ; then \
						eval ___MASTER_SITES_TMP=\$${_MASTER_SITES_$${group}} ; \
						__MASTER_SITES_TMP="$${__MASTER_SITES_TMP} $${___MASTER_SITES_TMP}" ; \
					fi \
				done; \
				___MASTER_SITES_TMP= ; \
				SORTED_MASTER_SITES_CMD_TMP="${ECHO_CMD} ${_MASTER_SITE_OVERRIDE} `${ECHO_CMD} $${__MASTER_SITES_TMP} | ${AWK} '${MASTER_SORT_AWK:S|\\|\\\\|g}'` ${_MASTER_SITE_BACKUP}" ; \
			else \
				SORTED_MASTER_SITES_CMD_TMP="${SORTED_MASTER_SITES_DEFAULT_CMD}" ; \
			fi ; \
			for site in `eval $$SORTED_MASTER_SITES_CMD_TMP ${_RANDOMIZE_SITES}`; do \
				case $${file} in \
				*/*)	args="-o $${file} $${site}$${file}";; \
				*)		args=$${site}$${file};; \
				esac; \
				${ECHO_CMD} $${args} ; \
			done; \
		fi \
	done)
.if defined(PATCHFILES)
	@(cd ${_DISTDIR}; \
	${_PATCH_SITES_ENV} ; \
	for _file in ${PATCHFILES}; do \
		file=`${ECHO_CMD} $$_file | ${SED} -E -e 's/:[^-:][^:]*$$//'` ; \
		if [ $$_file = $$file ]; then	\
			select='';	\
		else	\
			select=`${ECHO_CMD} $${_file##*:} | ${SED} -e 's/,/ /g'` ;	\
		fi;	\
		file=`${ECHO_CMD} $$file | ${SED} -E -e 's/:-[^:]+$$//'` ; \
		fileptn=`${ECHO_CMD} $$file | ${SED} 's|/|\\\\/|g;s/\./\\\\./g;s/\+/\\\\+/g;s/\?/\\\\?/g'` ; \
		if [ ! -z "${LISTALL}" -o ! -f $$file -a ! -f $${file##*/} ]; then \
			if [ ! -z "$$select" ] ; then \
				__PATCH_SITES_TMP= ; \
				for group in $$select; do \
					if [ ! -z \$${_PATCH_SITES_$${group}} ] ; then \
						eval ___PATCH_SITES_TMP=\$${_PATCH_SITES_$${group}} ; \
						__PATCH_SITES_TMP="$${__PATCH_SITES_TMP} $${___PATCH_SITES_TMP}" ; \
					fi \
				done; \
				___PATCH_SITES_TMP= ; \
				SORTED_PATCH_SITES_CMD_TMP="${ECHO_CMD} ${_MASTER_SITE_OVERRIDE} `${ECHO_CMD} $${__PATCH_SITES_TMP} | ${AWK} '${MASTER_SORT_AWK:S|\\|\\\\|g}'` ${_MASTER_SITE_BACKUP}" ; \
			else \
				SORTED_PATCH_SITES_CMD_TMP="${SORTED_PATCH_SITES_DEFAULT_CMD}" ; \
			fi ; \
			for site in `eval $$SORTED_PATCH_SITES_CMD_TMP ${_RANDOMIZE_SITES}`; do \
				case $${file} in \
				*/*)	args="-o $${file} $${site}$${file}";; \
				*)		args=$${site}$${file};; \
				esac; \
				${ECHO_CMD} $${args} ; \
			done; \
		fi \
	 done)
.endif
.endif

.if !target(fetch-urlall-list)
fetch-urlall-list:
	@cd ${.CURDIR} && LISTALL=yes ${MAKE} fetch-url-list-int
.endif

.if !target(fetch-url-list)
fetch-url-list: fetch-url-list-int
.endif

# Generates patches.

update-patches:


# Checksumming utilities

# List all algorithms here, all the variables name must begin with dp_
_CHECKSUM_INIT_ENV= \
	dp_SHA256=${SHA256}
	\
	for alg in ${CHECKSUM_ALGORITHMS:tu}; do \
		eval alg_executable=\$$$$alg; \
		if [ -z "$$alg_executable" ]; then \
			${ECHO_MSG} "Checksum algorithm $$alg: Couldn't find the executable."; \
			${ECHO_MSG} "Set $$alg=/path/to/$$alg in /etc/make.conf and try again."; \
			exit 1; \
		fi; \
	done; \

checksum_init=\
	SHA256=${SHA256};

.if !target(makesum)
# Some port change the options with OPTIONS_*_FORCE when make(makesum) to be
# able to add all distfiles in one go.
# For this to work, we need to call the do-fetch script directly here so that
# the options consistent when fetching and when makesum'ing.
# As we're fetching new distfiles, that are not in the distinfo file, disable
# checksum and sizes checks.
makesum:
.if !empty(DISTFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_MASTER_SITES_ENV} \
			dp_NO_CHECKSUM=yes dp_DISABLE_SIZE=yes \
			dp_SITE_FLAVOR=MASTER \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${DISTFILES:C/.*/'&'/}
.endif
.if defined(PATCHFILES) && !empty(PATCHFILES)
	@${SETENV} \
			${_DO_FETCH_ENV} ${_PATCH_SITES_ENV} \
			dp_NO_CHECKSUM=yes dp_DISABLE_SIZE=yes \
			dp_SITE_FLAVOR=PATCH \
			${SH} ${SCRIPTSDIR}/do-fetch.sh ${PATCHFILES:C/.*/'&'/}
.endif
	@${SETENV} \
			${_CHECKSUM_INIT_ENV} \
			dp_CHECKSUM_ALGORITHMS='${CHECKSUM_ALGORITHMS:tu}' \
			dp_CKSUMFILES='${_CKSUMFILES}' \
			dp_DISTDIR='${DISTDIR}' \
			dp_DISTINFO_FILE='${DISTINFO_FILE}' \
			dp_ECHO_MSG='${ECHO_MSG}' \
			dp_SCRIPTSDIR='${SCRIPTSDIR}' \
			${SH} ${SCRIPTSDIR}/makesum.sh ${DISTFILES:C/.*/'&'/}
.endif

.if !target(checksum)
checksum: fetch
.if !empty(_CKSUMFILES)
	@${SETENV} \
			${_CHECKSUM_INIT_ENV} \
			dp_CHECKSUM_ALGORITHMS='${CHECKSUM_ALGORITHMS:tu}' \
			dp_CURDIR='${.CURDIR}' \
			dp_DISTDIR='${DISTDIR}' \
			dp_DISTINFO_FILE='${DISTINFO_FILE}' \
			dp_DIST_SUBDIR='${DIST_SUBDIR}' \
			dp_ECHO_MSG='${ECHO_MSG}' \
			dp_FETCH_REGET='${FETCH_REGET}' \
			dp_MAKE='${MAKE}' \
			dp_MAKEFLAGS='${.MAKEFLAGS}' \
			dp_SCRIPTSDIR='${SCRIPTSDIR}' \
			dp_DISABLE_SIZE='${DISABLE_SIZE}' \
			dp_NO_CHECKSUM='${NO_CHECKSUM}' \
			${SH} ${SCRIPTSDIR}/checksum.sh ${_CKSUMFILES:C/.*/'&'/}
.endif
				\
				if [ $$ignore = "false" -a -z "$$CKSUM" ]; then \
					${ECHO_MSG} "=> No $$alg checksum recorded for $$file."; \
					ignore="true"; \
				fi; \
				\
				if [ $$ignore = "false" ]; then \
					match="false"; \
					for chksum in $$CKSUM; do \
						if [ "$$chksum" = "$$MKSUM" ]; then \
							match="true"; \
							break; \
						fi; \
					done; \
					if [ $$match = "true" ]; then \
						${ECHO_MSG} "=> $$alg Checksum OK for $$file."; \
						ignored="false"; \
					else \
						${ECHO_MSG} "=> $$alg Checksum mismatch for $$file."; \
						refetchlist="$$refetchlist$$file "; \
						OK="$${OK:-retry}"; \
						[ "$${OK}" = "retry" -a ${FETCH_REGET} -gt 0 ] && ${RM} -f $${file}; \
						ignored="false"; \
					fi; \
				fi; \
			done; \
			\
			if [ $$ignored = "true" ]; then \
				${ECHO_MSG} "=> No suitable checksum found for $$file."; \
				OK="${FALSE}"; \
			fi; \
			\
		done; \
		\
		if [ "$${OK:=true}" = "retry" ] && [ ${FETCH_REGET} -gt 0 ]; then \
			${ECHO_MSG} "===>  Refetch for ${FETCH_REGET} more times files: $$refetchlist"; \
			if ( cd ${.CURDIR} && \
			    ${MAKE} ${.MAKEFLAGS} FORCE_FETCH="$$refetchlist" FETCH_REGET="`${EXPR} ${FETCH_REGET} - 1`" fetch); then \
				  if ( cd ${.CURDIR} && \
			        ${MAKE} ${.MAKEFLAGS} FETCH_REGET="`${EXPR} ${FETCH_REGET} - 1`" checksum ); then \
				      OK="true"; \
				  fi; \
			fi; \
		fi; \
		\
		if [ "$$OK" != "true" -a ${FETCH_REGET} -eq 0 ]; then \
			${ECHO_MSG} "===>  Giving up on fetching files: $$refetchlist"; \
			${ECHO_MSG} "Make sure the Makefile and distinfo file (${DISTINFO_FILE})"; \
			${ECHO_MSG} "are up to date.  If you are absolutely sure you want to override this"; \
			${ECHO_MSG} "check, type \"make NO_CHECKSUM=yes [other args]\"."; \
			exit 1; \
		fi; \
		if [ "$$OK" != "true" ]; then \
			exit 1; \
		fi; \
	elif [ -n "${_CKSUMFILES:M*}" ]; then \
		${ECHO_MSG} "=> No checksum file (${DISTINFO_FILE})."; \
		exit 1; \
	fi
.endif

################################################################

Return to bug 208916

Lines 216-218 export_ports_env() { Link Here

(-)Mk/Scripts/functions.sh (+28 lines)
216	fi	216	fi
217	done	217	done
218	}	218	}
		219
		220	distinfo_data() {
		221	local alg file
		222
		223	alg=$1
		224	file=$2
		225
		226	if [ \( -n "${dp_DISABLE_SIZE}" -a -n "${dp_NO_CHECKSUM}" \) -o ! -f "${dp_DISTINFO_FILE}" ]; then
		227	exit
		228	fi
		229	awk -v alg="$alg" -v file="${file}" \
		230	'$1 == alg && $2 == "(" file ")" {print $4}' "${dp_DISTINFO_FILE}"
		231	}
		232
		233	check_checksum_algorithms() {
		234	for alg in ${dp_CHECKSUM_ALGORITHMS}; do
		235	eval "alg_executable=\$dp_$alg"
		236	if [ -z "$alg_executable" ]; then
		237	${dp_ECHO_MSG} "Checksum algorithm $alg: Couldn't find the executable."
		238	${dp_ECHO_MSG} "Set $alg=/path/to/$alg in /etc/make.conf and try again."
		239	exit 1
		240	elif [ ! -x "$alg_executable" ]; then
		241	${dp_ECHO_MSG} "Checksum algorithm $alg: $alg_executable is not executable."
		242	${dp_ECHO_MSG} "Fix modes, or change $alg=$alg_executable in /etc/make.conf and try again."
		243	exit 1
		244	fi
		245	done
		246	}

Added Link Here

(-)Mk/Scripts/check-vulnerable.sh (+35 lines)
1	#!/bin/sh
2	# $FreeBSD$
3	#
4	# MAINTAINER: portmgr@FreeBSD.org
5
6	set -e
7
8	. "${dp_SCRIPTSDIR}/functions.sh"
9
10	validate_env dp_ECHO_MSG dp_PKG_BIN dp_PORTNAME
11
12	set -u
13
14	# If the package is pkg, disable these checks, it fails while
15	# upgrading when pkg is not there.
16	# FIXME: check is this is still true
17	if [ "${dp_PORTNAME}" = "pkg" ]; then
18	exit 0
19	fi
20
21	if [ -x "${dp_PKG_BIN}" ]; then
22	vlist=$(${dp_PKG_BIN} audit "${dp_PKGNAME}" \|\| :)
23	if [ "${vlist}" = "0 problem(s) in the installed packages found." ]; then
24	vlist=""
25	fi
26	fi
27
28	if [ -n "$vlist" ]; then
29	${dp_ECHO_MSG} "===> ${dp_PKGNAME} has known vulnerabilities:"
30	${dp_ECHO_MSG} "$vlist"
31	${dp_ECHO_MSG} "=> Please update your ports tree and try again."
32	${dp_ECHO_MSG} "=> Note: Vulnerable ports are marked as such even if there is no update available."
33	${dp_ECHO_MSG} "=> If you wish to ignore this vulnerability rebuild with 'make DISABLE_VULNERABILITIES=yes'"
34	exit 1
35	fi

Added Link Here

(-)Mk/Scripts/checksum.sh (+89 lines)
1	#!/bin/sh
2	# $FreeBSD$
3	#
4	# MAINTAINER: portmgr@FreeBSD.org
5
6	set -e
7
8	. "${dp_SCRIPTSDIR}/functions.sh"
9
10	validate_env dp_CHECKSUM_ALGORITHMS dp_CURDIR dp_DISTDIR dp_DISTINFO_FILE \
11	dp_DIST_SUBDIR dp_ECHO_MSG dp_FETCH_REGET dp_MAKE dp_MAKEFLAGS \
12	dp_DISABLE_SIZE dp_NO_CHECKSUM
13
14	set -u
15
16	check_checksum_algorithms
17
18	if [ -f "${dp_DISTINFO_FILE}" ]; then
19	cd "${dp_DISTDIR}"
20	OK=
21	refetchlist=
22	for file in "${@}"; do
23	ignored="true"
24	for alg in ${dp_CHECKSUM_ALGORITHMS}; do
25	ignore="false"
26	eval "alg_executable=\$dp_${alg}"
27
28	if [ "$alg_executable" != "NO" ]; then
29	MKSUM=$(eval $alg_executable \< "${file}")
30	CKSUM=$(distinfo_data "${alg}" "${file}")
31	else
32	ignore="true"
33	fi
34
35	if [ $ignore = "false" -a -z "$CKSUM" ]; then
36	${dp_ECHO_MSG} "=> No $alg checksum recorded for $file."
37	ignore="true"
38	fi
39
40	if [ $ignore = "false" ]; then
41	match="false"
42	for chksum in $CKSUM; do
43	if [ "$chksum" = "$MKSUM" ]; then
44	match="true"
45	break
46	fi
47	done
48	if [ $match = "true" ]; then
49	${dp_ECHO_MSG} "=> $alg Checksum OK for $file."
50	ignored="false"
51	else
52	${dp_ECHO_MSG} "=> $alg Checksum mismatch for $file."
53	refetchlist="$refetchlist $file "
54	OK="${OK:-retry}"
55	[ "${OK}" = "retry" -a "${dp_FETCH_REGET}" -gt 0 ] && rm -f "${file}"
56	ignored="false"
57	fi
58	fi
59	done
60
61	if [ $ignored = "true" ]; then
62	${dp_ECHO_MSG} "=> No suitable checksum found for $file."
63	OK=false
64	fi
65	done
66
67	if [ "${OK:=true}" = "retry" ] && [ "${dp_FETCH_REGET}" -gt 0 ]; then
68	${dp_ECHO_MSG} "===> Refetch for ${dp_FETCH_REGET} more times files: $refetchlist"
69	if ${dp_MAKE} -C "${dp_CURDIR}" ${dp_MAKEFLAGS} FORCE_FETCH_LIST="$refetchlist" FETCH_REGET="$((dp_FETCH_REGET - 1))" fetch; then
70	if ${dp_MAKE} -C "${dp_CURDIR}" ${dp_MAKEFLAGS} FETCH_REGET="$((dp_FETCH_REGET - 1))" checksum ; then
71	OK="true"
72	fi
73	fi
74	fi
75
76	if [ "$OK" != "true" -a "${dp_FETCH_REGET}" -eq 0 ]; then
77	${dp_ECHO_MSG} "===> Giving up on fetching files: $refetchlist"
78	${dp_ECHO_MSG} "Make sure the Makefile and distinfo file (${dp_DISTINFO_FILE})"
79	${dp_ECHO_MSG} "are up to date. If you are absolutely sure you want to override this"
80	${dp_ECHO_MSG} "check, type \"make NO_CHECKSUM=yes [other args]\"."
81	exit 1
82	fi
83	if [ "$OK" != "true" ]; then
84	exit 1
85	fi
86	elif [ -n "${@}" ]; then
87	${dp_ECHO_MSG} "=> No checksum file (${DISTINFO_FILE})."
88	exit 1
89	fi

Added Link Here

(-)Mk/Scripts/do-fetch.sh (+171 lines)
1	#!/bin/sh
2	# $FreeBSD$
3	#
4	# MAINTAINER: portmgr@FreeBSD.org
5
6	set -e
7
8	. "${dp_SCRIPTSDIR}/functions.sh"
9
10	validate_env dp_DEVELOPER dp_DISABLE_SIZE dp_DISTDIR dp_DISTINFO_FILE \
11	dp_DIST_SUBDIR dp_ECHO_MSG dp_FETCH_AFTER_ARGS dp_FETCH_BEFORE_ARGS \
12	dp_FETCH_CMD dp_FETCH_ENV dp_FORCE_FETCH_ALL dp_FORCE_FETCH_LIST \
13	dp_MASTER_SITE_BACKUP dp_MASTER_SITE_OVERRIDE dp_MASTER_SORT_AWK \
14	dp_NO_CHECKSUM dp_RANDOMIZE_SITES dp_SITE_FLAVOR dp_SCRIPTSDIR \
15	dp_SORTED_MASTER_SITES_DEFAULT_CMD dp_SORTED_PATCH_SITES_DEFAULT_CMD \
16	dp_TARGET
17
18	set -u
19
20	mkdir -p "${dp_DISTDIR}"
21	cd "${dp_DISTDIR}"
22
23	for _file in "${@}"; do
24	file=${_file%%:*}
25
26	# If this files has groups
27	if [ "$_file" = "$file" ]; then
28	select=''
29	else
30	select=$(echo "${_file##*:}" \| sed -e 's/,/ /g')
31	fi
32
33	filebasename=${file##*/}
34	if [ -n "${dp_FORCE_FETCH_ALL}" ]; then
35	force_fetch=true
36	else
37	force_fetch=false
38	for afile in ${dp_FORCE_FETCH_LIST}; do
39	afile=${afile##*/}
40	if [ "x$afile" = "x$filebasename" ]; then
41	force_fetch=true
42	fi
43	done
44	fi
45	if [ ! -f "$file" -a ! -f "$filebasename" -o "$force_fetch" = "true" ]; then
46	full_file="${dp_DIST_SUBDIR:+${dp_DIST_SUBDIR}/}${file}"
47	if [ -L "$file" -o -L "$filebasename" ]; then
48	${dp_ECHO_MSG} "=> ${dp_DISTDIR}/$file is a broken symlink."
49	${dp_ECHO_MSG} "=> Perhaps a filesystem (most likely a CD) isn't mounted?"
50	${dp_ECHO_MSG} "=> Please correct this problem and try again."
51	exit 1
52	fi
53	if [ -f "${dp_DISTINFO_FILE}" -a -z "${dp_NO_CHECKSUM}" ]; then
54	_sha256sum=$(distinfo_data SHA256 "${full_file}")
55	if [ -z "$_sha256sum" ]; then
56	${dp_ECHO_MSG} "=> ${dp_DIST_SUBDIR:+$dp_DIST_SUBDIR/}$file is not in ${dp_DISTINFO_FILE}."
57	${dp_ECHO_MSG} "=> Either ${dp_DISTINFO_FILE} is out of date, or"
58	${dp_ECHO_MSG} "=> ${dp_DIST_SUBDIR:+$dp_DIST_SUBDIR/}$file is spelled incorrectly."
59	exit 1
60	fi
61	fi
62	case ${dp_TARGET} in
63	do-fetch\|makesum)
64	${dp_ECHO_MSG} "=> $file doesn't seem to exist in ${dp_DISTDIR}."
65	;;
66	esac
67	if [ ! -w "${dp_DISTDIR}" ]; then
68	${dp_ECHO_MSG} "=> ${dp_DISTDIR} is not writable by you; cannot fetch."
69	exit 1
70	fi
71	if [ -n "$select" ] ; then
72	__MASTER_SITES_TMP=
73	for group in $select; do
74	# Disable nounset for this, it may come up empty.
75	set +u
76	eval ___MASTER_SITES_TMP="\${_${dp_SITE_FLAVOR}_SITES_${group}}"
77	set -u
78	if [ -n "${___MASTER_SITES_TMP}" ] ; then
79	__MASTER_SITES_TMP="${__MASTER_SITES_TMP} ${___MASTER_SITES_TMP}"
80	else
81	case ${dp_TARGET} in
82	do-fetch\|makesum)
83	if [ -n "${dp_DEVELOPER}" ]; then
84	${dp_ECHO_MSG} "===> /!\\ Error /!\\"
85	else
86	${dp_ECHO_MSG} "===> /!\\ Warning /!\\"
87	fi
88	${dp_ECHO_MSG} " The :${group} group used for $file is missing"
89	${dp_ECHO_MSG} " from ${dp_SITE_FLAVOR}_SITES. Check for typos, or errors."
90	if [ -n "${dp_DEVELOPER}" ]; then
91	exit 1
92	fi
93	;;
94	esac
95
96	fi
97	done
98	___MASTER_SITES_TMP=
99	SORTED_MASTER_SITES_CMD_TMP="echo ${dp_MASTER_SITE_OVERRIDE} $(echo -n "${__MASTER_SITES_TMP}" \| awk "${dp_MASTER_SORT_AWK}") ${dp_MASTER_SITE_BACKUP}"
100	else
101	if [ ${dp_SITE_FLAVOR} = "MASTER" ]; then
102	SORTED_MASTER_SITES_CMD_TMP="${dp_SORTED_MASTER_SITES_DEFAULT_CMD}"
103	else
104	SORTED_MASTER_SITES_CMD_TMP="${dp_SORTED_PATCH_SITES_DEFAULT_CMD}"
105	fi
106	fi
107	case ${dp_TARGET} in
108	fetch-list)
109	echo -n "mkdir -p ${dp_DISTDIR} && "
110	echo -n "cd ${dp_DISTDIR} && { "
111	;;
112	esac
113	sites_remaining=0
114	sites="$(eval "${SORTED_MASTER_SITES_CMD_TMP} ${dp_RANDOMIZE_SITES}")"
115	for site in ${sites}; do
116	sites_remaining=$((sites_remaining + 1))
117	done
118	for site in ${sites}; do
119	sites_remaining=$((sites_remaining - 1))
120	CKSIZE=$(distinfo_data SIZE "${full_file}")
121	# The site may contain special shell characters, they
122	# need to be escaped.
123	site=$(echo "${site}" \| sed -e 's/[&;()#]/\\&/g')
124	# There is a lot of escaping, but the " needs to survive echo/eval.
125	case ${file} in
126	/)
127	mkdir -p "${file%/*}"
128	args="-o \\\"${file}\\\" \\\"${site}${file}\\\""
129	;;
130	*)
131	args="\\\"${site}${file}\\\""
132	;;
133	esac
134	_fetch_cmd=$(eval "echo ${dp_FETCH_ENV} ${dp_FETCH_CMD} ${dp_FETCH_BEFORE_ARGS} ${args} ${dp_FETCH_AFTER_ARGS}")
135	case ${dp_TARGET} in
136	do-fetch\|makesum)
137	${dp_ECHO_MSG} "=> Attempting to fetch ${site}${file}"
138	if eval "env ${_fetch_cmd}"; then
139	actual_size=$(eval stat -f %z "${file}")
140	if [ -n "${dp_DISABLE_SIZE}" ] \|\| [ -z "${CKSIZE}" ] \|\| [ "${actual_size}" -eq "${CKSIZE}" ]; then
141	continue 2
142	else
143	${dp_ECHO_MSG} "=> Fetched file size mismatch (expected ${CKSIZE}, actual ${actual_size})"
144	if [ ${sites_remaining} -gt 0 ]; then
145	${dp_ECHO_MSG} "=> Trying next site"
146	rm -f "${file}"
147	fi
148	fi
149	fi
150	;;
151	fetch-list)
152	echo -n "env ${_fetch_cmd} \|\| "
153	;;
154	fetch-url-list-int)
155	eval "echo $(eval "echo ${args}")"
156	;;
157	esac
158	done
159	case ${dp_TARGET} in
160	do-fetch\|makesum)
161	${dp_ECHO_MSG} "=> Couldn't fetch it - please try to retrieve this"
162	${dp_ECHO_MSG} "=> port manually into ${dp_DISTDIR} and try again."
163	exit 1
164	;;
165	fetch-list)
166	echo "echo ${file} not fetched; }" ; \
167	;;
168	esac
169	fi
170	done
171

Added Link Here

(-)Mk/Scripts/makesum.sh (+51 lines)
1	#!/bin/sh
2	# $FreeBSD$
3	#
4	# MAINTAINER: portmgr@FreeBSD.org
5
6	set -e
7
8	. "${dp_SCRIPTSDIR}/functions.sh"
9
10	validate_env dp_CHECKSUM_ALGORITHMS dp_CKSUMFILES dp_DISTDIR dp_DISTINFO_FILE \
11	dp_ECHO_MSG
12
13	set -u
14
15	DISTINFO_OLD=$(mktemp -t makesum-old)
16	DISTINFO_NEW=$(mktemp -t makesum-new)
17
18	trap 'rm -f ${DISTINFO_OLD} ${DISTINFO_NEW}' EXIT INT TERM
19
20	check_checksum_algorithms
21
22	cd "${dp_DISTDIR}"
23
24	# Running `make makesum` a twice should not change the timestamp generated from
25	# the first run.
26	# So, we extract the content of the distinfo file minus the TIMESTAMP, if it
27	# contains a TIMESTAMP.
28	if [ -f "${dp_DISTINFO_FILE}" ] && grep -q "^TIMESTAMP " ${dp_DISTINFO_FILE}; then
29	grep -v "^TIMESTAMP " ${dp_DISTINFO_FILE} > ${DISTINFO_OLD}
30	fi
31
32	for file in ${dp_CKSUMFILES}; do
33	for alg in ${dp_CHECKSUM_ALGORITHMS}; do
34	eval "alg_executable=\$dp_$alg"
35
36	if [ "$alg_executable" != "NO" ]; then
37	$alg_executable "$file" >> "${DISTINFO_NEW}"
38	fi
39	done
40	echo "SIZE ($file) = $(stat -f %z "$file")" >> "${DISTINFO_NEW}"
41	done
42
43	# Now, we generate the distinfo file in two cases:
44	# - If the saved file is empty, it means there was no TIMESTAMP in it, so we
45	# need to add one.
46	# - If the old and new distinfo content minus the TIMESTAMP differ, it means
47	# something was updated or changed, it is time to generate a new timestamp.
48	if [ ! -s ${DISTINFO_OLD} ] \|\| ! cmp -s ${DISTINFO_OLD} ${DISTINFO_NEW}; then
49	echo "TIMESTAMP = $(date '+%s')" > ${dp_DISTINFO_FILE}
50	cat ${DISTINFO_NEW} >> ${dp_DISTINFO_FILE}
51	fi