313 lines
7.6 KiB
Bash
Executable File
313 lines
7.6 KiB
Bash
Executable File
#!/bin/sh
|
|
|
|
set -u
|
|
|
|
ME=$(basename $0)
|
|
|
|
USAGE="Usage: ${ME} {options}
|
|
|
|
Builds a license metadata specification and outputs it to stdout or {outfile}.
|
|
|
|
The available options are:
|
|
|
|
-k kind... license kinds
|
|
-c condition... license conditions
|
|
-p package... license package name
|
|
-n notice... license notice file
|
|
-d dependency... license metadata file dependency
|
|
-t target... targets
|
|
-m target:installed... map dependent targets to their installed names
|
|
-is_container preserved dependent target name when given
|
|
-o outfile output file
|
|
"
|
|
|
|
# Global flag variables
|
|
license_kinds=
|
|
license_conditions=
|
|
license_package_name=
|
|
license_notice=
|
|
license_deps=
|
|
targets=
|
|
installmap=
|
|
is_container=false
|
|
ofile=
|
|
|
|
# Global variables
|
|
depfiles=" "
|
|
effective_conditions=
|
|
|
|
|
|
# Exits with a message.
|
|
#
|
|
# When the exit status is 2, assumes a usage error and outputs the usage message
|
|
# to stderr before outputting the specific error message to stderr.
|
|
#
|
|
# Parameters:
|
|
# Optional numeric exit status (defaults to 2, i.e. a usage error.)
|
|
# Remaining args treated as an error message sent to stderr.
|
|
die() {
|
|
lstatus=2
|
|
case "${1:-}" in *[^0-9]*) ;; *) lstatus="$1"; shift ;; esac
|
|
case "${lstatus}" in 2) echo "${USAGE}" >&2; echo >&2 ;; esac
|
|
if [ -n "$*" ]; then
|
|
echo -e "$*\n" >&2
|
|
fi
|
|
exit $lstatus
|
|
}
|
|
|
|
|
|
# Sets the flag variables based on the command-line.
|
|
#
|
|
# invoke with: process_args "$@"
|
|
process_args() {
|
|
lcurr_flag=
|
|
while [ "$#" -gt '0' ]; do
|
|
case "${1}" in
|
|
-h)
|
|
echo "${USAGE}"
|
|
exit 0
|
|
;;
|
|
-k)
|
|
lcurr_flag=kind
|
|
;;
|
|
-c)
|
|
lcurr_flag=condition
|
|
;;
|
|
-p)
|
|
lcurr_flag=package
|
|
;;
|
|
-n)
|
|
lcurr_flag=notice
|
|
;;
|
|
-d)
|
|
lcurr_flag=dependency
|
|
;;
|
|
-t)
|
|
lcurr_flag=target
|
|
;;
|
|
-m)
|
|
lcurr_flag=installmap
|
|
;;
|
|
-o)
|
|
lcurr_flag=ofile
|
|
;;
|
|
-is_container)
|
|
lcurr_flag=
|
|
is_container=true
|
|
;;
|
|
-*)
|
|
die "Unknown flag: \"${1}\""
|
|
;;
|
|
*)
|
|
case "${lcurr_flag}" in
|
|
kind)
|
|
license_kinds="${license_kinds}${license_kinds:+ }${1}"
|
|
;;
|
|
condition)
|
|
license_conditions="${license_conditions}${license_conditions:+ }${1}"
|
|
;;
|
|
package)
|
|
license_package_name="${license_package_name}${license_package_name:+ }${1}"
|
|
;;
|
|
notice)
|
|
license_notice="${license_notice}${license_notice:+ }${1}"
|
|
;;
|
|
dependency)
|
|
license_deps="${license_deps}${license_deps:+ }${1}"
|
|
;;
|
|
target)
|
|
targets="${targets}${targets:+ }${1}"
|
|
;;
|
|
installmap)
|
|
installmap="${installmap}${installmap:+ }${1}"
|
|
;;
|
|
ofile)
|
|
if [ -n "${ofile}" ]; then
|
|
die "Output file -o appears twice as \"${ofile}\" and \"${1}\""
|
|
fi
|
|
ofile="${1}"
|
|
;;
|
|
*)
|
|
die "Must precede argument \"${1}\" with type flag."
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
}
|
|
|
|
# Reads a license metadata file from stdin, and outputs the named dependencies.
|
|
#
|
|
# No parameters.
|
|
extract_deps() {
|
|
awk '$1 == "dep_name:" { sub(/^"/, "", $2); sub(/"$/, "", $2); print $2; }'
|
|
}
|
|
|
|
# Populates the depfiles variable identifying dependency files.
|
|
#
|
|
# Starting with the dependencies enumerated in license_deps, calculates the
|
|
# transitive closure of all dependencies.
|
|
#
|
|
# Dependency names ending in .meta_module indirectly reference license
|
|
# metadata with 1 license metadata filename per line.
|
|
#
|
|
# No parameters; no output.
|
|
read_deps() {
|
|
lnewdeps=
|
|
for d in ${license_deps}; do
|
|
case "${d}" in
|
|
*.meta_module)
|
|
lnewdeps="${lnewdeps}${lnewdeps:+ }"$(cat "${d}") ;;
|
|
*)
|
|
lnewdeps="${lnewdeps}${lnewdeps:+ }${d}" ;;
|
|
esac
|
|
done
|
|
lnewdeps=$(echo "${lnewdeps}" | tr ' ' '\n' | sort -u)
|
|
lalldeps=
|
|
ldeps=
|
|
lmod=
|
|
ldep=
|
|
while [ "${#lnewdeps}" -gt '0' ]; do
|
|
ldeps="${lnewdeps}"
|
|
lnewdeps=
|
|
for ldep in ${ldeps}; do
|
|
depfiles="${depfiles}${ldep} "
|
|
lalldeps="${lalldeps}${lalldeps:+ }"$(cat "${ldep}" | extract_deps)
|
|
done
|
|
lalldeps=$(for d in ${lalldeps}; do echo "${d}"; done | sort -u)
|
|
for d in ${lalldeps}; do
|
|
ldeps="${d}"
|
|
case "${d}" in *.meta_module) ldeps=$(cat "${d}") ;; esac
|
|
for lmod in ${ldeps}; do
|
|
if ! expr "${depfiles}" : ".* ${lmod} .*" >/dev/null 2>&1; then
|
|
lnewdeps="${lnewdeps}${lnewdeps:+ }${lmod}"
|
|
fi
|
|
done
|
|
done
|
|
lalldeps=
|
|
done
|
|
}
|
|
|
|
# Returns the effective license conditions for the current license metadata.
|
|
#
|
|
# If a module is restricted or links in a restricted module, the effective
|
|
# license has a restricted condition.
|
|
calculate_effective_conditions() {
|
|
lconditions="${license_conditions}"
|
|
case "${license_conditions}" in
|
|
*restricted*) : do nothing ;;
|
|
*)
|
|
for d in ${depfiles}; do
|
|
if cat "${d}" | egrep -q 'effective_condition\s*:.*restricted' ; then
|
|
lconditions="${lconditions}${lconditions:+ }restricted"
|
|
fi
|
|
done
|
|
;;
|
|
esac
|
|
echo "${lconditions}"
|
|
}
|
|
|
|
|
|
process_args "$@"
|
|
|
|
if [ -n "${ofile}" ]; then
|
|
# truncate the output file before appending results
|
|
: >"${ofile}"
|
|
else
|
|
ofile=/dev/stdout
|
|
fi
|
|
|
|
# spit out the license metadata file content
|
|
(
|
|
echo 'license_package_name: "'${license_package_name}'"'
|
|
for kind in ${license_kinds}; do
|
|
echo 'license_kind: "'${kind}'"'
|
|
done
|
|
for condition in ${license_conditions}; do
|
|
echo 'license_condition: "'${condition}'"'
|
|
done
|
|
for f in ${license_notice}; do
|
|
echo 'license_text: "'${f}'"'
|
|
done
|
|
echo "is_container: ${is_container}"
|
|
for t in ${targets}; do
|
|
echo 'target: "'${t}'"'
|
|
done
|
|
for m in ${installmap}; do
|
|
echo 'install_map: "'${m}'"'
|
|
done
|
|
) >>"${ofile}"
|
|
read_deps
|
|
effective_conditions=$(calculate_effective_conditions)
|
|
for condition in ${effective_conditions}; do
|
|
echo 'effective_condition: "'${condition}'"'
|
|
done >>"${ofile}"
|
|
for dep in ${depfiles}; do
|
|
echo 'dep {'
|
|
cat "${dep}" | \
|
|
awk -v name="${dep}" '
|
|
function strip_type() {
|
|
$1 = ""
|
|
sub(/^\s*/, "")
|
|
}
|
|
BEGIN {
|
|
print " dep_name: " name
|
|
}
|
|
$1 == "license_package_name:" {
|
|
strip_type()
|
|
print " dep_package_name: "$0
|
|
}
|
|
$1 == "dep_name:" {
|
|
print " dep_sub_dep: "$2
|
|
}
|
|
$1 == "license_kind:" {
|
|
print " dep_license_kind: "$2
|
|
}
|
|
$1 == "license_condition:" {
|
|
print " dep_license_condition: "$2
|
|
}
|
|
$1 == "is_container:" {
|
|
print " dep_is_container: "$2
|
|
}
|
|
$1 == "license_text:" {
|
|
strip_type()
|
|
print " dep_license_text: "$0
|
|
}
|
|
$1 == "target:" {
|
|
print " dep_target: "$2
|
|
}
|
|
$1 == "install_map:" {
|
|
print " dep_install_map: "$2
|
|
}
|
|
'
|
|
# The restricted license kind is contagious to all linked dependencies.
|
|
dep_conditions=$(echo $(
|
|
cat "${dep}" | awk '
|
|
$1 == "effective_condition:" {
|
|
$1 = ""
|
|
sub(/^\s*/, "")
|
|
gsub(/"/, "")
|
|
print
|
|
}
|
|
'
|
|
))
|
|
for condition in ${dep_conditions}; do
|
|
echo ' dep_effective_condition: "'${condition}'"'
|
|
done
|
|
if ! ${is_container}; then
|
|
case "${dep_conditions}" in
|
|
*restricted*) : already restricted -- nothing to inherit ;;
|
|
*)
|
|
case "${effective_conditions}" in
|
|
*restricted*)
|
|
# "contagious" restricted infects everything linked to restricted
|
|
echo ' dep_effective_condition: "restricted"'
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
fi
|
|
echo '}'
|
|
done >>"${ofile}"
|