By Jonathan Corbet
February 1, 2012
The eLinux.org web site is currently promoting
a project to write
a replacement for Busybox under a permissive license. Normally, the
writing of more free software is seen as a good thing, but, in this case,
there have been
complaints about the
perceived motivation behind the project. What this
discussion shows is that there are some divisions within our community on
how our licenses should be enforced - and even what those licenses say.
One could imagine a number of reasons for wanting to rewrite Busybox. Over
time, that package has grown to the point that it's not quite the
minimal-footprint tool kit that it once was. Android-based systems can
certainly benefit from the addition of Busybox, but the Android world tends
to be allergic to GPL-licensed software; a non-GPL Busybox might even find
a place in the standard Android distribution. But the project page makes
another reason abundantly clear:
Busybox is arguably the most litigated piece of GPL software in the
world. Unfortunately, it is unclear what the remedy should be when
a GPL violation occurs with busybox. Litigants have sometimes
requested remedies outside the scope of busybox itself, such as
review authority over unrelated products, or right of refusal over
non-busybox modules. This causes concern among chip vendors and
suppliers.
What seems to be happening in particular is that the primary Busybox
litigant - the Software Freedom Conservancy (SFC) - has taken the termination
language in GPLv2 to mean that somebody who fails to comply with the
license loses all rights to the relevant software, even after they fix
their compliance problems. (See Android and
the GPLv2 death penalty for more information on this interpretation of
the license, which is not universally held). Under this interpretation,
they are withholding the restoration of a license to use and distribute
Busybox based on conditions that are not directly related to Busybox; among
other things, they require compliance for all other free software products
shipped by that company, including the Linux kernel.
Thus, according to Matthew Garrett:
The reason to replace Busybox isn't because they don't want to hand
over the source to Busybox - it's because Busybox is being used as
a proxy to obtain the source code for more interesting GPLed
works. People want a Busybox replacement in order to make it easier
to infringe the kernel's license.
There is some truth to the notion that, on its own, license enforcement for
Busybox is not hugely interesting. Encouraging compliance with the GPL is
a good thing, but, beyond that, there is little to be gained by prying the
source for a Busybox distribution from a vendor's hands. There just isn't
anything interesting being added to Busybox by those vendors. Rob Landley,
who was once one of the Software Freedom Law Center's plaintiffs (before
the enforcement work moved to the Software Freedom Conservancy) once wrote:
From a purely pragmatic perspective: I spent over a year doing
busybox license enforcement, and a dozen lawsuits later I'm still
unaware of a SINGLE LINE OF CODE added to the busybox repository as
a result...
Rob has been working on the Toybox
project, which happens to be the effort that would someday like to
replace Busybox, since 2006.
So, beyond the generation of bad publicity for a violator and some cash for
the litigants, Busybox enforcement on its own could perhaps be said to
achieve relatively little for the community. But a vendor that can't be
bothered to provide a tarball for an unmodified Busybox distribution is
highly unlikely to have its act together with regard to other projects,
starting with the kernel. And that vendor's kernel code can often be the
key to understanding their hardware and supporting it in free software. So
it is not surprising that a group engaging in GPL enforcement would insist
on the release of the kernel source as well.
On its face, it does seem surprising that vendors would object to
this requirement - unless they overtly wish to get away with GPL
infringement. Tim Bird, who is promoting the Busybox
replacement project, has stated that this
is not the case. Instead, Tim says:
It is NOT the goal of this to help people violate the GPL, but
rather to decrease the risk of some nuclear outcome, should a
mistake be made somewhere in the supply chain for a product. For
example, it is possible for a mistake made by an ODM (like
providing the wrong busybox source version) could result in the
recall of millions of unrelated products. As it stands, the demands
made by the SFC in order to bring a company back into compliance
are beyond the value that busybox provides to a company.
Mistakes do happen. Companies are often surprisingly unaware of where their
code comes from or what version they may have shipped in a given product.
Often, the initial violation comes from upstream suppliers, with the final
vendor being entirely unaware that they are shipping GPL-licensed software
at all. What is being claimed here is that SFC's demands are causing the
consequences of any such mistakes to be more than companies are willing to
risk.
What does the SFC require of infringers? The SFC demands, naturally
enough, that the requirements of the GPL be met for the version of Busybox
shipped by an
infringer. There are also demands for an unknown amount of financial
compensation, both to the SFC (The SFC's FY2010
IRS filings show just over $200,000 in revenue from legal
settlements) and to the Busybox developer (Erik Andersen)
that the SFC is representing.
Then there are the demands for compliance
for all other GPL-licensed products shipped by the vendor, demands that, it
is alleged, extend to the source for binary-only kernel modules. The SFC also
evidently demands that future products be submitted to them for a
compliance audit before being shipped to customers.
Such demands may well be appropriate for habitual GPL infringers; they are,
arguably, a heavy penalty for a mistake. Whether the cases filed by the
SFC relate to habitual behavior or mistakes is not necessarily clear; there
have been plenty of allegations either way. One person's mistake is
another person's intentional abuse.
If Busybox is, for whatever reason, especially mistake-prone, then
replacing it with a mistake-proof, BSD-licensed version might make sense.
Not using the software at all is certainly a way to avoid infringing its
license. What is a bit more surprising is that some developers are
lamenting the potential loss of Busybox as a lever for the enforcement of
conditions on the use of the kernel. There are a couple of concerns here:
- The use of the GPL death penalty is worrisome, in that it gives
any copyright holder extreme power over anybody who can be said to
have infringed the license in any trivial way. Even if one is fully
in agreement with the SFC's use of the termination clause, there are,
beyond doubt, entities out there who would like to use it in ways that
are not in the interests of the free software community.
- One could argue that enforcement of the licenses for other software
packages should be left up to the developers who wrote that code.
They may have different ideas about how it should be done or even
what compliance means. Any
developer with copyrights in the kernel (or any other product) is
entirely capable of going to the SFC if they want SFC-style
enforcement of their rights.
For such a developer to go to the SFC is exactly what Matthew is asking for
in his post. Thus far, despite a search for plaintiffs on the SFC's part,
that has not happened. Why that might be is not entirely clear. Perhaps
kernel developers are not comfortable with how the SFC goes about its
business, or perhaps it's something else. It's worth noting that most
kernel developers are employed by companies these days, with the result
that much of their output is owned by their employers. For whatever reason,
companies have shown remarkably little taste for GPL enforcement in
any form, so a lot of kernel code is not available to be put into play in
an enforcement action.
That last point is, arguably, a real flaw in the corporate-sponsored free
software development model - at least, if the viability of copyleft
licenses matters. The GPL, like almost any set of rules, will require
occasional enforcement if its rules are to be respected; if corporations
own the bulk of the code, and they are unwilling to be part of that
enforcement effort, respect for the GPL will decrease. One could argue
that scenario is exactly what is playing out now; one could also argue that
it is causing Busybox, by virtue of being the only project for which active
enforcement is happening, to be unfairly highlighted as the bad guy. If
GPL enforcement were spread across a broader range of projects, it would be
harder for companies to route around - unless, as some fear, that
enforcement would drive companies away from GPL-licensed software altogether.
Situations like this one show that there is an increasing amount of
frustration building in our community. Some vendors and some developers
are clearly unhappy with how some license enforcement is being done, and
they are taking action in response. But there is also a lot of anger over
the blatant disregard for the requirements of the GPL at many companies;
that, too, is inspiring people to act. There are a number of undesirable
worst-case outcomes that could result. On one side, GPL infringement could
reach a point where projects like the kernel are, for all practical effect,
BSD-licensed. Or GPL enforcement could become so oppressive that vendors
flee to code that is truly BSD licensed. Avoiding these outcomes will
almost certainly require finding a way to enforce our licenses that most of
us can agree with.
(
Log in to post comments)