2011-04-21 11:26:25 +00:00
# Populates LICENSE_DIRECTORY as set in distro config with the license files as set by
2011-12-05 01:03:37 +00:00
# LIC_FILES_CHKSUM.
2011-01-27 19:25:12 +00:00
# TODO:
2011-12-03 23:16:15 +00:00
# - There is a real issue revolving around license naming standards.
2011-01-27 19:25:12 +00:00
2011-05-17 09:47:53 +00:00
LICENSE_DIRECTORY ??= "${DEPLOY_DIR}/licenses"
2011-02-03 12:33:18 +00:00
LICSSTATEDIR = "${WORKDIR}/license-destdir/"
2011-01-27 19:25:12 +00:00
2011-12-10 16:42:40 +00:00
addtask populate_lic after do_patch before do_package
2011-02-03 12:33:18 +00:00
do_populate_lic[dirs] = "${LICSSTATEDIR}/${PN}"
do_populate_lic[cleandirs] = "${LICSSTATEDIR}"
2011-05-25 20:58:35 +00:00
# Standards are great! Everyone has their own. In an effort to standardize licensing
# names, common-licenses will use the SPDX standard license names. In order to not
# break the non-standardized license names that we find in LICENSE, we'll set
# up a bunch of VarFlags to accomodate non-SPDX license names.
#
2011-12-05 01:03:37 +00:00
# We should really discuss standardizing this field, but that's a longer term goal.
2011-05-25 20:58:35 +00:00
# For now, we can do this and it should grab the most common LICENSE naming variations.
2011-12-03 23:16:15 +00:00
#
# We should NEVER have a GPL/LGPL without a version!!!!
# Any mapping to MPL/LGPL/GPL should be fixed
# see: https://wiki.yoctoproject.org/wiki/License_Audit
# GPL variations
2012-03-23 23:51:40 +00:00
SPDXLICENSEMAP[GPL-1] = "GPL-1.0"
SPDXLICENSEMAP[GPLv1] = "GPL-1.0"
SPDXLICENSEMAP[GPLv1.0] = "GPL-1.0"
2011-12-03 23:16:15 +00:00
SPDXLICENSEMAP[GPL-2] = "GPL-2.0"
SPDXLICENSEMAP[GPLv2] = "GPL-2.0"
SPDXLICENSEMAP[GPLv2.0] = "GPL-2.0"
SPDXLICENSEMAP[GPL-3] = "GPL-3.0"
SPDXLICENSEMAP[GPLv3] = "GPL-3.0"
SPDXLICENSEMAP[GPLv3.0] = "GPL-3.0"
2011-05-25 20:58:35 +00:00
#LGPL variations
2011-12-03 23:16:15 +00:00
SPDXLICENSEMAP[LGPLv2] = "LGPL-2.0"
2012-03-12 23:18:21 +00:00
SPDXLICENSEMAP[LGPLv2.0] = "LGPL-2.0"
2011-05-25 20:58:35 +00:00
SPDXLICENSEMAP[LGPL2.1] = "LGPL-2.1"
SPDXLICENSEMAP[LGPLv2.1] = "LGPL-2.1"
2011-12-03 23:16:15 +00:00
SPDXLICENSEMAP[LGPLv3] = "LGPL-3.0"
2011-05-25 20:58:35 +00:00
#MPL variations
2011-12-03 23:16:15 +00:00
SPDXLICENSEMAP[MPL-1] = "MPL-1.0"
SPDXLICENSEMAP[MPLv1] = "MPL-1.0"
SPDXLICENSEMAP[MPLv1.1] = "MPL-1.1"
2011-05-25 20:58:35 +00:00
#MIT variations
SPDXLICENSEMAP[MIT-X] = "MIT"
2011-12-03 23:16:15 +00:00
SPDXLICENSEMAP[MIT-style] = "MIT"
2011-05-25 20:58:35 +00:00
#Openssl variations
2011-11-02 12:26:40 +00:00
SPDXLICENSEMAP[openssl] = "OpenSSL"
2011-05-25 20:58:35 +00:00
2011-12-03 23:16:15 +00:00
#Python variations
SPDXLICENSEMAP[PSF] = "Python-2.0"
SPDXLICENSEMAP[PSFv2] = "Python-2.0"
SPDXLICENSEMAP[Python-2] = "Python-2.0"
#Apache variations
SPDXLICENSEMAP[Apachev2] = "Apache-2.0"
SPDXLICENSEMAP[Apache-2] = "Apache-2.0"
#Artistic variations
SPDXLICENSEMAP[Artisticv1] = "Artistic-1.0"
SPDXLICENSEMAP[Artistic-1] = "Artistic-1.0"
#Academic variations
SPDXLICENSEMAP[AFL-2] = "AFL-2.0"
SPDXLICENSEMAP[AFL-1] = "AFL-1.2"
SPDXLICENSEMAP[AFLv2] = "AFL-2.0"
SPDXLICENSEMAP[AFLv1] = "AFL-1.2"
2011-05-25 20:58:35 +00:00
#Other variations
2011-12-03 23:16:15 +00:00
SPDXLICENSEMAP[EPLv1.0] = "EPL-1.0"
license_create_manifest() {
2012-03-23 23:51:44 +00:00
mkdir -p ${LICENSE_DIRECTORY}/${IMAGE_NAME}
# Get list of installed packages
list_installed_packages | grep -v "locale" |sort > ${LICENSE_DIRECTORY}/${IMAGE_NAME}/package.manifest
INSTALLED_PKGS=`cat ${LICENSE_DIRECTORY}/${IMAGE_NAME}/package.manifest`
2012-03-29 12:22:29 +00:00
# remove existing license.manifest file
if [ -f ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest ]; then
rm ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
fi
2012-03-23 23:51:44 +00:00
# list of installed packages is broken for deb
for pkg in ${INSTALLED_PKGS}; do
# not the best way to do this but licenses are not arch dependant iirc
2012-05-30 19:01:15 +00:00
filename=`ls ${TMPDIR}/pkgdata/*/runtime/${pkg}| head -1`
pkged_pn="$(sed -n 's/^PN: //p' ${filename})"
pkged_lic="$(sed -n '/^LICENSE: /{ s/^LICENSE: //; s/[+|&()*]/ /g; s/ */ /g; p }' ${filename})"
pkged_pv="$(sed -n 's/^PV: //p' ${filename})"
# check to see if the package name exists in the manifest. if so, bail.
if ! grep -q "PACKAGE NAME: ${pkg}" ${filename}; then
# exclude local recipes
if [ ! "${pkged_pn}" = "*locale*" ]; then
echo "PACKAGE NAME:" ${pkg} >> ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
echo "PACKAGE VERSION:" ${pkged_pv} >> ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
echo "RECIPE NAME:" ${pkged_pn} >> ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
echo "LICENSE: " >> ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
for lic in ${pkged_lic}; do
if [ -e "${LICENSE_DIRECTORY}/${pkged_pn}/generic_${lic}" ]; then
echo ${lic}|sed s'/generic_//'g >> ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
else
echo "WARNING: The license listed, " ${lic} " was not in the licenses collected for " ${pkged_pn}>> ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
fi
done
echo "" >> ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest
2012-03-23 23:51:44 +00:00
fi
2012-05-30 19:01:15 +00:00
fi
2012-03-23 23:51:44 +00:00
done
# Two options here:
# - Just copy the manifest
# - Copy the manifest and the license directories
# With both options set we see a .5 M increase in core-image-minimal
if [ -n "${COPY_LIC_MANIFEST}" ]; then
mkdir -p ${IMAGE_ROOTFS}/usr/share/common-licenses/
cp ${LICENSE_DIRECTORY}/${IMAGE_NAME}/license.manifest ${IMAGE_ROOTFS}/usr/share/common-licenses/license.manifest
if [ -n "${COPY_LIC_DIRS}" ]; then
for pkg in ${INSTALLED_PKGS}; do
mkdir -p ${IMAGE_ROOTFS}/usr/share/common-licenses/${pkg}
for lic in `ls ${LICENSE_DIRECTORY}/${pkg}`; do
# Really don't need to copy the generics as they're
# represented in the manifest and in the actual pkg licenses
# Doing so would make your image quite a bit larger
if [[ "${lic}" != "generic_"* ]]; then
cp ${LICENSE_DIRECTORY}/${pkg}/${lic} ${IMAGE_ROOTFS}/usr/share/common-licenses/${pkg}/${lic}
elif [[ "${lic}" == "generic_"* ]]; then
if [ ! -f ${IMAGE_ROOTFS}/usr/share/common-licenses/${lic} ]; then
cp ${LICENSE_DIRECTORY}/${pkg}/${lic} ${IMAGE_ROOTFS}/usr/share/common-licenses/
fi
ln -s ../${lic} ${IMAGE_ROOTFS}/usr/share/common-licenses/${pkg}/${lic}
fi
done
done
fi
fi
2011-12-03 23:16:15 +00:00
}
2011-01-27 19:25:12 +00:00
python do_populate_lic() {
"""
Populate LICENSE_DIRECTORY with licenses.
"""
import os
import bb
import shutil
2011-12-05 01:03:37 +00:00
import oe.license
2011-05-25 20:58:35 +00:00
2012-02-24 22:17:38 +00:00
pn = d.getVar('PN', True)
for package in d.getVar('PACKAGES', True):
if d.getVar('LICENSE_' + pn + '-' + package, True):
license_types = license_types + ' & ' + \
d.getVar('LICENSE_' + pn + '-' + package, True)
#If we get here with no license types, then that means we have a recipe
#level license. If so, we grab only those.
try:
license_types
except NameError:
# All the license types at the recipe level
license_types = d.getVar('LICENSE', True)
2011-12-03 23:16:15 +00:00
# All the license files for the package
lic_files = d.getVar('LIC_FILES_CHKSUM', True)
pn = d.getVar('PN', True)
# The base directory we wrangle licenses to
destdir = os.path.join(d.getVar('LICSSTATEDIR', True), pn)
# The license files are located in S/LIC_FILE_CHECKSUM.
srcdir = d.getVar('S', True)
# Directory we store the generic licenses as set in the distro configuration
generic_directory = d.getVar('COMMON_LICENSE_DIR', True)
license_source_dirs = []
license_source_dirs.append(generic_directory)
try:
additional_lic_dirs = d.getVar('LICENSE_DIR', True).split()
for lic_dir in additional_lic_dirs:
license_source_dirs.append(lic_dir)
except:
pass
2011-12-05 01:03:37 +00:00
class FindVisitor(oe.license.LicenseVisitor):
2011-05-25 20:58:35 +00:00
def visit_Str(self, node):
#
# Until I figure out what to do with
# the two modifiers I support (or greater = +
# and "with exceptions" being *
2011-12-05 01:03:37 +00:00
# we'll just strip out the modifier and put
2011-05-25 20:58:35 +00:00
# the base license.
find_license(node.s.replace("+", "").replace("*", ""))
2011-12-05 01:03:37 +00:00
self.generic_visit(node)
2011-05-25 20:58:35 +00:00
def find_license(license_type):
try:
bb.mkdirhier(gen_lic_dest)
except:
pass
2011-12-03 23:16:15 +00:00
spdx_generic = None
license_source = None
2011-05-25 20:58:35 +00:00
# If the generic does not exist we need to check to see if there is an SPDX mapping to it
2011-12-03 23:16:15 +00:00
for lic_dir in license_source_dirs:
if not os.path.isfile(os.path.join(lic_dir, license_type)):
if d.getVarFlag('SPDXLICENSEMAP', license_type) != None:
# Great, there is an SPDXLICENSEMAP. We can copy!
bb.debug(1, "We need to use a SPDXLICENSEMAP for %s" % (license_type))
spdx_generic = d.getVarFlag('SPDXLICENSEMAP', license_type)
license_source = lic_dir
break
elif os.path.isfile(os.path.join(lic_dir, license_type)):
spdx_generic = license_type
license_source = lic_dir
break
if spdx_generic and license_source:
# we really should copy to generic_ + spdx_generic, however, that ends up messing the manifest
# audit up. This should be fixed in emit_pkgdata (or, we actually got and fix all the recipes)
2012-04-03 11:05:48 +00:00
bb.copyfile(os.path.join(license_source, spdx_generic), os.path.join(os.path.join(d.getVar('LICSSTATEDIR', True), pn), "generic_" + license_type))
if not os.path.isfile(os.path.join(os.path.join(d.getVar('LICSSTATEDIR', True), pn), "generic_" + license_type)):
2011-12-03 23:16:15 +00:00
# If the copy didn't occur, something horrible went wrong and we fail out
bb.warn("%s for %s could not be copied for some reason. It may not exist. WARN for now." % (spdx_generic, pn))
else:
# And here is where we warn people that their licenses are lousy
bb.warn("%s: No generic license file exists for: %s in any provider" % (pn, license_type))
pass
2011-12-05 01:03:37 +00:00
2011-05-25 20:58:35 +00:00
try:
bb.mkdirhier(destdir)
except:
pass
2011-01-27 19:25:12 +00:00
if not generic_directory:
raise bb.build.FuncFailed("COMMON_LICENSE_DIR is unset. Please set this in your distro config")
if not lic_files:
# No recipe should have an invalid license file. This is checked else
# where, but let's be pedantic
bb.note(pn + ": Recipe file does not have license file information.")
return True
for url in lic_files.split():
(type, host, path, user, pswd, parm) = bb.decodeurl(url)
# We want the license file to be copied into the destination
srclicfile = os.path.join(srcdir, path)
ret = bb.copyfile(srclicfile, os.path.join(destdir, os.path.basename(path)))
# If the copy didn't occur, something horrible went wrong and we fail out
2011-12-03 23:16:15 +00:00
if not ret:
2011-01-27 19:25:12 +00:00
bb.warn("%s could not be copied for some reason. It may not exist. WARN for now." % srclicfile)
2011-12-05 01:03:37 +00:00
v = FindVisitor()
try:
v.visit_string(license_types)
except oe.license.InvalidLicense as exc:
2011-12-10 00:05:24 +00:00
bb.fatal('%s: %s' % (d.getVar('PF', True), exc))
except SyntaxError:
bb.warn("%s: Failed to parse it's LICENSE field." % (d.getVar('PF', True)))
2011-01-27 19:25:12 +00:00
}
2011-02-03 12:33:18 +00:00
2012-03-23 23:51:42 +00:00
def return_spdx(d, license):
"""
This function returns the spdx mapping of a license.
2012-01-10 15:17:58 +00:00
"""
2012-03-23 23:51:42 +00:00
if d.getVarFlag('SPDXLICENSEMAP', license) != None:
return license
else:
return d.getVarFlag('SPDXLICENSEMAP', license_type)
def incompatible_license(d, dont_want_license, package=""):
"""
This function checks if a recipe has only incompatible licenses. It also take into consideration 'or'
2012-01-10 15:17:58 +00:00
operand.
"""
import re
import oe.license
from fnmatch import fnmatchcase as fnmatch
2012-03-23 23:51:42 +00:00
pn = d.getVar('PN', True)
2012-01-10 15:17:58 +00:00
dont_want_licenses = []
2012-03-03 10:59:25 +00:00
dont_want_licenses.append(d.getVar('INCOMPATIBLE_LICENSE', True))
2012-03-23 23:51:42 +00:00
recipe_license = d.getVar('LICENSE', True)
if package != "":
if d.getVar('LICENSE_' + pn + '-' + package, True):
license = d.getVar('LICENSE_' + pn + '-' + package, True)
else:
license = recipe_license
else:
license = recipe_license
spdx_license = return_spdx(d, dont_want_license)
dont_want_licenses.append(spdx_license)
2012-01-10 15:17:58 +00:00
def include_license(license):
2012-03-23 23:51:41 +00:00
if any(fnmatch(license, pattern) for pattern in dont_want_licenses):
return False
else:
return True
2012-01-10 15:17:58 +00:00
def choose_licenses(a, b):
if all(include_license(lic) for lic in a):
2012-03-23 23:51:41 +00:00
return a
2012-01-10 15:17:58 +00:00
else:
2012-03-23 23:51:41 +00:00
return b
2012-01-10 15:17:58 +00:00
"""
If you want to exlude license named generically 'X', we surely want to exlude 'X+' as well.
In consequence, we will exclude the '+' character from LICENSE in case INCOMPATIBLE_LICENSE
is not a 'X+' license.
"""
if not re.search(r'[+]',dont_want_license):
2012-03-23 23:51:42 +00:00
licenses=oe.license.flattened_licenses(re.sub(r'[+]', '', license), choose_licenses)
2012-01-10 15:17:58 +00:00
else:
2012-03-23 23:51:42 +00:00
licenses=oe.license.flattened_licenses(license, choose_licenses)
2012-01-10 15:17:58 +00:00
for onelicense in licenses:
2012-03-23 23:51:41 +00:00
if not include_license(onelicense):
return True
2012-01-10 15:17:58 +00:00
return False
license.bbclass: add support for LICENSE_FLAGS
LICENSE_FLAGS are a per-recipe replacement for the COMMERCIAL_LICENSE
mechanism.
In the COMMERCIAL_LICENSE mechanism, any package name mentioned in the
global COMMERCIAL_LICENSE list is 'blacklisted' from being included in
an image. To allow the blacklisted package into the image, the
corresponding packages need to be removed from the COMMERCIAL_LICENSE
list. This mechanism relies on a global list defined in
default-distrovars.inc.
The LICENSE_FLAGS mechanism essentially implements the same thing but
turns the global blacklist into a per-recipe whitelist. Any recipe
can optionally define one or more 'license flags'; if defined, each of
the license flags defined for a recipe must have matching entries in a
global LICENSE_FLAGS_WHITELIST variable.
The definition of 'matching' is simple, but there are a couple things
users need to know in order to correctly and effectively use it.
Before we test a flag against the whitelist, we append _${PN} to it,
thus automatically making each LICENSE_FLAG recipe-specific. We then
try to match that string against the whitelist. So if the user
specifies LICENSE_FLAGS = 'commercial' for recipe 'foo', the string
'commercial_foo' should be specified in the whitelist in order for it
to match.
However, the user can also broaden the match by putting any
'_'-separated beginning subset of a LICENSE_FLAG in the whitelist,
which will also match e.g. simply specifying 'commercial' in the
whitelist would match any expanded LICENSE_FLAG starting with
'commercial' such as 'commercial_foo' and 'commercial_bar' which are
the strings that would have been automatically generated if those
recipes had simply specified LICENSE_FLAGS = 'commercial'
This allows for a range of specificity for the items in the whitelist,
from more general to perfectly specific. So users have the choice of
exhaustively enumerating each license flag in the whitelist to allow
only those specific recipes into the image, or of using a more general
string to pick up anything matching just the first component(s).
Note that this scheme works even if the flag already has _pn appended
- the extra _pn is redundant, but doesn't affect the outcome e.g. a
license flag of 'commercial_1.2_foo' would turn into
'commercial_1.2_foo_foo' and would match both the general 'commercial'
and the specific 'commercial_1.2_foo' as expected (it would also match
commercial_1.2_foo_foo' and 'commercial_1.2', which don't make much
sense as far as something a user would think of specifying in the
whitelist). For a versioned string, the user could instead specify
'commercial_foo_1.2', which would turn into 'commercial_foo_1.2_foo',
but which would as expected allow the user to pick up this package
along with anything else 'commercial' by specifying 'commercial' in
the whitelist, or anything with a 'commercial_foo' license regardless
of version by using 'commercial_foo' in the whitelist, or
'commercial_foo_1.1' to be completely specific about package and
version.
The current behavior of COMMERCIAL_LICENSE is replicated as mentioned
above by having the current set of COMMERCIAL_LICENSE flags
implemented using LICENSE_FLAGS = "commercial".
That being the case, the current COMMERCIAL_LICENSE can equivalently
be specified in the new scheme by putting the below in local.conf:
# This is a list of packages that require a commercial license to ship
# product. If shipped as part of an image these packages may have
# implications so they are disabled by default. To enable them,
# un-comment the below as appropriate.
#LICENSE_FLAGS_WHITELIST = "commercial_gst-fluendo-mp3 \
# commercial_gst-openmax \
# commercial_gst-plugins-ugly \
# commercial_lame \
# commercial_libmad \
# commercial_libomxil \
# commercial_mpeg2dec \
# commercial_qmmp"
The above allows all of the current COMMERCIAL_LICENSE packages in -
to disallow a particular package from appearing in the image, simply
remove it from the whitelist. To allow them all in, you could also
specify LICENSE_FLAGS_WHITELIST = "commercial".
(From OE-Core rev: a2760661b8c7a4a1b6f2e556853b3a9ae38cbcb5)
Signed-off-by: Tom Zanussi <tom.zanussi@intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2011-12-31 19:06:39 +00:00
def check_license_flags(d):
"""
This function checks if a recipe has any LICENSE_FLAGs that
aren't whitelisted.
If it does, it returns the first LICENSE_FLAG missing from the
whitelist, or all the LICENSE_FLAGs if there is no whitelist.
If everything is is properly whitelisted, it returns None.
"""
def license_flag_matches(flag, whitelist, pn):
"""
Return True if flag matches something in whitelist, None if not.
Before we test a flag against the whitelist, we append _${PN}
to it. We then try to match that string against the
whitelist. This covers the normal case, where we expect
LICENSE_FLAGS to be a simple string like 'commercial', which
the user typically matches exactly in the whitelist by
explicitly appending the package name e.g 'commercial_foo'.
If we fail the match however, we then split the flag across
'_' and append each fragment and test until we either match or
run out of fragments.
"""
flag_pn = ("%s_%s" % (flag, pn))
for candidate in whitelist:
if flag_pn == candidate:
return True
flag_cur = ""
flagments = flag_pn.split("_")
flagments.pop() # we've already tested the full string
for flagment in flagments:
if flag_cur:
flag_cur += "_"
flag_cur += flagment
for candidate in whitelist:
if flag_cur == candidate:
return True
return False
def all_license_flags_match(license_flags, whitelist):
""" Return first unmatched flag, None if all flags match """
pn = d.getVar('PN', True)
split_whitelist = whitelist.split()
for flag in license_flags.split():
if not license_flag_matches(flag, split_whitelist, pn):
return flag
return None
license_flags = d.getVar('LICENSE_FLAGS', True)
if license_flags:
whitelist = d.getVar('LICENSE_FLAGS_WHITELIST', True)
if not whitelist:
return license_flags
unmatched_flag = all_license_flags_match(license_flags, whitelist)
if unmatched_flag:
return unmatched_flag
return None
2011-02-03 12:33:18 +00:00
SSTATETASKS += "do_populate_lic"
do_populate_lic[sstate-name] = "populate-lic"
do_populate_lic[sstate-inputdirs] = "${LICSSTATEDIR}"
do_populate_lic[sstate-outputdirs] = "${LICENSE_DIRECTORY}/"
2012-07-05 14:48:23 +00:00
ROOTFS_POSTPROCESS_COMMAND_prepend = "license_create_manifest; "
2011-12-03 23:16:15 +00:00
2011-02-03 12:33:18 +00:00
python do_populate_lic_setscene () {
sstate_setscene(d)
}
addtask do_populate_lic_setscene