
Google's Android faces a serious Linux copyright issue - FlorianMueller
http://fosspatents.blogspot.com/2011/03/googles-android-faces-serious-linux.html
======
sjs382
_Google copied 2.5 megabytes of code from more than 700 Linux kernel header
files with a homemade program that drops source code comments and some other
elements, and daringly claims (in a notice at the start of each generated
file) that the extracted material constitutes "no copyrightable information"._

Uh, what?

 _If Google is proven wrong, pretty much that entire software stack -- and
also many popular third-party closed-source components such as the Angry Birds
game and the Adobe Flash Player -- would actually have to be published under
the GPL._

Stopped reading after this...

~~~
anon1385
If you link to GPL libraries you must abide by the terms of the GPL. The same
applies to using the kernel header files. Or at least Torvalds believes this
to be the case, as do the IP lawyers quoted[1]. Quote from Linus:

 _"In short: you do _NOT_ have the right to use a kernel header file (or any
other part of the kernel sources), unless that use results in a GPL'd
program."_

 _"So you can run the kernel and create non-GPL'd programs […] BUT YOU CAN NOT
USE THE KERNEL HEADER FILES TO CREATE NON-GPL'D BINARIES. Comprende?"_

The solution seems to be to re-licence Bionic under the LGPL, which is what
the C libraries of every other linux based OS do. Although that does seem to
suggest that one can always work around the GPL linking restriction by
creating an intermediate LGPL library, but I'm no lawyer so maybe there is
some reason that is not allowed.

[1]
[http://www.brownrudnick.com/nr/pdf/alerts/Brown%20Rudnick%20...](http://www.brownrudnick.com/nr/pdf/alerts/Brown%20Rudnick%20Advisory%20The%20Bionic%20Library-
Did%20Google%20Work%20Around%20The%20GPL.pdf)

~~~
cabalamat
I'm sure that Linus does not think that programs that run on the Linux kernel
should have to be GPL'd. I doubt if Angry Birds or Flash use kernel header
files -- they call the kernel, yes, but as userspace programs not as part of
the kernel.

~~~
FlorianMueller
Linus Torvalds says that "normal system calls" are allowed, but once you use
the original kernel headers, you're subject to the GPL:
<http://lkml.org/lkml/2003/12/5/13> The way to avoid this is to use glibc.

~~~
Tibbes
In relation to Android and Bionic, I think the following message from the same
thread is more relevant:

<http://lkml.org/lkml/2003/12/5/162>

(in general, the thread was about kernel modules - this message explicitly
mentions user-space)

------
jmillikin
Oy, this guy _again_? For those unaware, Florian Mueller has made a mini-
career of spreading anti-FOSS and anti-Android propaganda.

    
    
      > Google copied 2.5 megabytes of code from more than 700
      > Linux kernel header files with a homemade program that
      > drops source code comments and some other elements, and
      > daringly claims (in a notice at the start of each
      > generated file) that the extracted material constitutes
      > "no copyrightable information".
    

In the US, APIs are typically considered mere specifications, and cannot be
copyrighted. You can copyright a particular encoding of an API (eg, a C .h
file), but the API _itself_ can be used by anyone. If APIs could be
copyrighted, projects like Wine and Mono would be illegal.

Whether Google's libraries are considered derived works will depend on how the
tool works. If it just regexes out all the comments, then the result is
probably a derivative work. If it parses the headers and then outputs the API
information, the output is probably not a derived work.

    
    
      > The GPL's copyleft nature requires all derivative works
      > of a GPL'd program to be made available on the same
      > terms.
    

Wrong; the GPL requires any derivative works to be under a _compatible_
license. If I copy GPL-licensed code into my BSD-licensed library, none of my
code has to be relicensed.

    
    
      > If Google is proven wrong, pretty much that entire
      > software stack -- and also many popular third-party
      > closed-source components such as the Angry Birds game
      > and the Adobe Flash Player -- would actually have to be
      > published under the GPL.
    

Completely and egregiously wrong. Unless these programs are actually copying
parts of the kernel into their source, they are not derived works.

Come on, this is software copyright 101. Copyright doesn't propagate from a
library to its clients; otherwise, every Windows application is infringing
Microsoft's copyrights, every iOS app is infringing Apple's, etc.

    
    
      > The only realistic way to fix the problem: replace
      > Bionic with glibc
    

How would this help? According to the author's reasoning, glibc is also an
illegal derivative work of the Linux kernel. Any application which infringes
if it uses Bionic will also infringe if linked against glibc.

The rest of the post is a bunch of doomsday scenarios, all built on the
incorrect assumption that running proprietary software on a Free kernel/libc
is illegal.

~~~
arst
_If I copy GPL-licensed code into my BSD-licensed library, none of my code has
to be relicensed._

Yes it does, that's a pretty central feature of the GPL. See section 2.b. of
the GPL (v2):

 _b) You must cause any work that you distribute or publish, that in whole or
in part contains or is derived from the Program or any part thereof, to be
licensed as a whole at no charge to all third parties under the terms of this
License._

~~~
jmillikin
You forgot the very next paragraph:

 _These requirements apply to the modified work as a whole. If identifiable
sections of that work are not derived from the Program, and can be reasonably
considered independent and separate works in themselves, then this License,
and its terms, do not apply to those sections when you distribute them as
separate works. But when you distribute the same sections as part of a whole
which is a work based on the Program, the distribution of the whole must be on
the terms of this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it._

In other words, my code remains mine. I still control the copyright to it, and
do not have to relicense it.

~~~
arst
Those conditions don't apply because Google is accused of distributing a
derived work. If Google is distributing a work derived from GPL'd code then
they can only distribute that work under the terms of the GPL. There's a lot
of debate over whether what Google's distributing can actually be considered a
derived work, but that's a separate question entirely.

------
rst
Odd that he doesn't explicitly mention the legal basis for Google's claim that
this stuff is non-copyrightable. Which is this:

Copyright protects the expression of an idea, not the idea itself. So, the
courts have held, if you don't have any choice over how to express something,
it isn't subject to copyright protection. In particular, if a particular
mapping from names to magic numbers is necessary in order for standard-
conformant programs to operate at all (as in the mappings specified by
<errno.h> and <signal.h>, which came up in the SCO litigation), that stuff
isn't copyrightable.

So, Google's saying, they've written tooling to explicitly drop all the
expressive elements, leaving the bare, functional, non-copyrightable bones ---
which they don't need legal permission to use, from Linus or anyone else.

This is, I guess, why Mueller thinks it's a big deal that the processed files
still include inline functions --- if there's another way to write the
function which does the same thing, then there is an expressive choice in
writing it, which would be subject to copyright protection.

But if userland code has no reason to want to run particular inline functions
in kernel header files, then Google has an easy remedy: just ditch 'em --- or
rewrite the few that matter, and ditch the rest.

So, this really doesn't look like a big deal...

~~~
aidenn0
I haven't looked at the code in question, but there are some inlined
functions. If there aren't too many and the functions are very short, then
it's probably fine.

Just copying the #defines and stuff is almost certainly okay since you would
need to duplicate all of that to call into the kernel.

There is precedent for something like this: Phone books have been copied,
proved to have been copied (there were fake entries in the original) and it
was determined not a copyright violation.

------
haberman
The Linux kernel _specifically_ allows programs to make system calls into the
kernel without being GPL. From <http://lxr.linux.no/linux+v2.6.38/COPYING>

    
    
        NOTE! This copyright does *not* cover user programs that use kernel
        services by normal system calls - this is merely considered normal use
        of the kernel, and does *not* fall under the heading of "derived work".
        Also note that the GPL below is copyrighted by the Free Software
        Foundation, but the instance of code that it refers to (the Linux
        kernel) is copyrighted by me and others who actually wrote it.
    

The Linus quote on the other hand, pertains to _binary modules_ \-- ie.
binaries that are linked into kernel-space and use _non-system-call_ APIs.

Since user programs are specifically exempt from being GPL'd, I cannot see how
you could possibly make the argument that Angry Birds is somehow affected,
unless it is being linked in as a kernel module.

What is in these headers? If it is just definitions that are required for
making system calls, I would expect that all of this falls under the exception
above.

------
mycroftiv
I think the part of the article everyone should make sure to focus on is that
Google is doing exactly what Linus says is impermissible. "In short: you do
_NOT_ have the right to use a kernel header file (or any other part of the
kernel sources), unless that use results in a GPL'd program." "So you can run
the kernel and create non-GPL'd programs [...] BUT YOU CAN NOT USE THE KERNEL
HEADER FILES TO CREATE NON-GPL'D BINARIES. Comprende?" - Linus Torvalds quote,
taken from the linked article

~~~
eli
An excellent point, though (unfortunately) just because Linus wants the GPL to
apply that way doesn't necessarily mean that it does.

As a layman, it seems entirely reasonable that you should be able to inspect
the interface of a software product in order to make something compatible with
it without your new product counting as a "derived work." If they had read
documentation for all the functions rather than parsing the headers through a
script would that have made a difference?

Put another way, I'm sure Microsoft asserts that it is impermissible to
reverse engineer Windows kernel code, but that doesn't mean they have the
power to stop it.

------
jcl
As I understand it, Google is using the header files only to extract
"structure declarations, constants, etc." -- i.e. to get the interface right,
not to link to kernel source. The question is whether or not this is a
copyright violation... If not, then the GPL has no power.

Note that it's possible to use a copyrighted source to reverse-engineer an
interface and not have it be a copyright violation:
<http://en.wikipedia.org/wiki/Clean_room_design#Case_law>

I'm hoping this is a lot of fuss over nothing, as there will no doubt be cases
in the future where people want to create open-source drop-in replacements for
proprietary systems, and if it is ruled that extracting information from
header files makes a derivative work, it will be very difficult for them to
get the interface right.

------
ajju
It's hard to take the author's claims of infringement seriously because of his
laughable claim that third party applications such as Angry Birds running on
top of Android would have to be open sourced under GPL if actual infringement
is found in Android.

~~~
FlorianMueller
The reason is that Angry Birds is written in C and certainly accesses the
Linux kernel, almost certainly using the Bionic library. If that one is GPL'd,
Angry Birds has to be GPL'd. GPL copyleft affects derivative works, and
compiling a library into your program is a clear case of a derivative work.

~~~
ajross
No, no, no. That's wrong. It's the "viral" misinterpretation of the GPL at
work. Angry Birds code belongs to Angry Birds' developers, period. They get to
decide its license, period. There are _no_ circumstances under which "Angry
Birds has to be GPL'd". None.

The issue at hand is whether or not the Angry Birds Android port constitutes a
derived work of the kernel (a pretty strained case, IMHO, given that it's a
straightforward port of a game from another non-linux platform). If it is,
then it can only be distributed under the GPL -- that is, it'd have to be
pulled from the market. At no point does it get removed from its owner's
control.

~~~
cube13
>The issue at hand is whether or not the Angry Birds Android port constitutes
a derived work of the kernel (a pretty strained case, IMHO, given that it's a
straightforward port of a game from another non-linux platform). If it is,
then it can only be distributed under the GPL -- that is, it'd have to be
pulled from the market. At no point does it get removed from its owner's
control.

The FSF states that if any program links against GPL licensed libraries, it is
a derivative work, and therefore needs to be under GPL as well. The LGPL was
created specifically to allow linking by code from other licenses.

While the Angry Birds code still belongs to the Angry Birds developers.
However, if Google is guilty of a GPL violation, and are unable to get a LGPL
licensed wrapper around the code, Angry Birds for Android may need to be
distributed under the GPL to avoid a violation.

Most likely, Google will find a way to make an LGPL wrapper, and this entire
issue won't matter.

~~~
nuclear_eclipse
Rovio will still never be forced to distribute Angry Birds under the GPL, even
if they are found to be a derived work by association. Being found of
infringement just means they have to stop distributing Angry Birds, _in it's
infringing form_. Once the infringement is fixed, Rovio can then distribute
the non-infringing form of Angry Birds without having to license it as GPL.

If however, Rovio wants to continue distributing the _infringing_ form of
Angry Birds, they only license they are legally allowed to use for that is the
GPL.

But at no point is Rovio ever _forced_ to distribute a GPL licensed version of
Angry Birds.

~~~
cube13
It is true that Rovio isn't forced by anyone to create a GPL version or to
release their code. I should have pointed this out.

However, their options are pretty limited, considering they want to make money
off of the software. They could simply stop distributing it from the platform.
But they want to make money, which means that they(presumably) want to get as
many sales of the game as possible on as many platforms as possible.

However, if the main system interface is GPL(and not LGPL), the GPL does not
allow anything to link against it that is not GPL code. So, given that, they
are effectively forced to do it if they want to get any further sales and ad
revenue on the Android platform, because they would not be able to distribute
the game in it's current version.

------
dminor
How not to get snookered by claims of "proof" of copyright infringement:
<http://www.groklaw.net/article.php?story=20110122054409107>

~~~
FlorianMueller
That Groklaw article failed to explain that the code in question is indeed
distributed online by major Android device makers such as Motorola, Samsung
and LG: [http://fosspatents.blogspot.com/2011/01/android-device-
maker...](http://fosspatents.blogspot.com/2011/01/android-device-makers-
distribute-oracle.html)

~~~
dminor
I'm not claiming it as truth - just letting people know that there's a history
here and opinions on both sides.

~~~
FlorianMueller
Thanks for clarifying that. Yes, let freedom and pluralism ring.

------
jrockway
I think the issue is whether or not header files are copyrightable. In
verbatim form, they are, but it's easy to recreate identical header files
without copying the source code: have someone read the header file, write a
list of functions and signatures, use this spec to write an identical header.
Google wrote a program to do this.

I am fine with the outcome either way. If everything on Linux has to be GPL'd,
excellent: more freedom for everyone. If Google's stuff is OK: that makes
sense too, because the OS's copyright shouldn't infect its apps'... apps have
to use an OS.

I love not having a pony in the race.

~~~
shareme
only problem the SCO case proved them not copyright-able..

whoops..

------
Sandman
Oh my, oh my, oh my...

 _Developers of applications using Bionic would only be able to charge (via
the Android Market) those customers who don't know what rights they have under
the GPL. All others would find ways to download and install those apps on GPL
terms, i.e., free of charge._

Mr. Mueller doesn't seem to understand that if something is released under GPL
that _does not_ make it automatically free of charge. Just because most GPL
software is free of charge, that does not mean that you can't charge for your
software if you release it as GPL.

Another common misconception is that if your code is under GPL, you have to
give the source code to just about anybody who wants to see it for free. No.
Wrong. Only people who have the license for your software can get the source
code, they have this right because it is granted to them by the GPL. And if
you want to, you can certainly charge for use of this license.

So there is nothing stopping you from releasing your software as GPL, charging
for it, and giving the source code to those interested parties that payed for
the license to use your software.

~~~
FlorianMueller
@Sandman, the "oh my, oh my, oh my" part is actually justified as a reaction
to some of what you say.

Of course you can try to charge for GPL'd software. But since the GPL requires
you to make it available free of charge, there would be arbitrage: people
would find where to get it for free, and why would they pay then?

~~~
teach
The GPL does _not_ require you to make your software available free of charge.
It merely states that if someone purchases software from you, that you must
also provide the source code upon request.

~~~
CrLf
But it requires that those who receive licenses from you (or source) be able
to pass them to others, free or charge or not.

~~~
tomjen3
So what?

It assumes that whomever wants to get your $3 program can:

* Know exactly what the rules are under the GPL (which as we have just seen, even smart software developers can't).

* Knows somebody who already have access to the software so he can get the source code.

* Trust the person whom he gets the software from.

* Knows how to compiler source code (or his friend has to), which means there has to be at least one programmer at some point. Programmers (especially with mobile programming experience) are not cheap.

* Is able to install the software, which again requires above average computer skills (many people don't know how to activate the menu)

Edit: formatting

* You will most likely be stuck with an out-of-date version, since Android programs are updated fairly often

So unless you sell something where the majority are computer programmers, or
are selling for a very high price, you properly wouldn't be able to get it for
free.

Edit:formatting.

------
tzs
A couple quick points about copyright and header files.

1\. It is well established in US copyright law that elements necessary to
interoperate with something aren't copyrightable. So, for instance, the
function signatures and probably function names (if names are necessary in
order to make the call) of an interface would not be copyrightable. Same for
structures used in the interface.

This has been fairly extensively litigated. It arises when you have, for
instance, someone trying to make an unauthorized third party game for a video
game system, or someone trying to write a plug-in for someone else's closed
program.

2\. Header files often contain more than just the bare elements necessary to
interface to something. They often contain macros that expand to code,
comments, maybe even implementations of small inline functions. There is
plenty in header files that can be copyrighted.

So, depending exactly on how Google produced its header files, they may be in
the clear or they may have made a big mistake.

~~~
cschwarm
According to Naughton's analysis [1], your case 2 applies, and there's also
the consideration that the whole constitutes an expression, and is therefore
copyrightable.

It's worth reading the original instead of the above linkbait.

[1]
[http://www.brownrudnick.com/nr/pdf/alerts/Brown%20Rudnick%20...](http://www.brownrudnick.com/nr/pdf/alerts/Brown%20Rudnick%20Advisory%20The%20Bionic%20Library-
Did%20Google%20Work%20Around%20The%20GPL.pdf)

------
JulianMorrison
So wait, the grumble is that they extracted function signatures from a header
file? What a non-event.

------
comex
I don't get it. The LGPL lets you promote to the GPL, but the GPL does not
give any special status to the LGPL; it doesn't even mention it outside of the
preamble. Why is going through a LGPL library any different than going through
a BSD one?

------
tzs
I am at a complete loss as to why no one like Google, or a consortium of
smaller embedded system developers or users, have not made a BSD based system
available as an alternative to Linux based systems.

Linux has some desktop advantages in terms of package management and perhaps
consumer hardware support, but none of these matter to someone seeking an OS
for a phone or a TV or a microwave oven and so on.

~~~
m0nastic
The precursor to Android was actually BSD-based instead of Linux-based. I
assume that when the Danger guys left to start over with Android, they figured
starting from Linux would give them a technical advantage.

------
radu_floricica
This may or may not be true, but what is fundamentally different from the
Oracle suit is that the GPL holders take a very pragmatic view of violations.
Release the code as GPL, or stop using it, and you're ok. I never heard of a
GPL suit involving damages... not even sure it's possible.

Oracle on the other hand wants either to hurt Android, or a (preferably large)
piece of the pie.

~~~
tonfa
"The SFC received a default judgment [PDF] against Westinghouse in July for
$90,000 in damages and $50,000 to cover costs of the suit."

<https://lwn.net/Articles/409303/>

------
CoffeeDregs
Interesting... Assuming the article is correct in that Google's tool says that
no copyrighted information is left, it seems that Google is saying that header
files stripped of all of english/whatever-language text and left with only
pure code are not copyright-able because it's just code?

~~~
wnoise
The argument is that it's just _interface_, which has to be that way for
interoperability, so has no "creative content". Code that is actually
expressive code in a header file (inline functions, or non-constant macros)
could readily spoil this. I have no idea whether the output headers contains
more than structure definitions, constant macros, and forward function
declarations.

------
nextparadigms
This is what you get when lawyers try to understand developer stuff. Plus, it
sounds like more FUD to me.

~~~
anon1385
Or possibly it's what happens when developers who don't understand legal stuff
try to circumvent software licences.

------
himmele
would it be possible to relicense the output of google's tools (the rewritten
kernel header files) to LGPL with the permission of the kernel developers
(just like glibc or uclibc do) and build a separate library out of this? This
library would consist mainly of header files. And this library can then be
linked against the rest of bionic whereat bionic could keep its current
license. Would this be ok?

