

Did Google Work Around The GPL? - anon1385
http://www.brownrudnick.com/nr/pdf/alerts/Brown%20Rudnick%20Advisory%20The%20Bionic%20Library-Did%20Google%20Work%20Around%20The%20GPL.pdf

======
mycroftiv
I have seen a lot of misinformation posted (and then strongly upvoted) in
another thread related to this controversy. I would like to offer a very
specific quotation which I believe illustrates the crux of the issue,
excerpted from the linked pdf:

Determining copyrightability is thus a fact-specific, case-by-case exercise.
In the case of the Linux kernel header files, most would likely be
copyrightable (even with comments removed) because the headers include many
macros, inline functions, and other logic that clearly qualifies as
expression. In fact, there are several Linux kernel header files that consist
almost entirely of static inline function, which is generally regarded as
copyrightable expression. For instance, the Linux kernel header file
<sys/byteorder.h> consists of an optimized byteswapping function that was
included by the Linux kernel developers because it was clever and well-written
– the kind of creativity that constitutes copyright protection. (The initial
thread from the Linux kernel mailing list that contributes this particular
inline function and discusses the performance benefit it supplies is available
at <http://lkml.org/lkml/2002/11/29/68> .) When it created the “clean” Bionic
headers, Google kept this inline function. See
[http://android.git.kernel.org/?p=platform/bionic.git;a=blob;...](http://android.git.kernel.org/?p=platform/bionic.git;a=blob;f=libc/kernel/archx86/asm/byteorder.h;h=a839798c8a476876968e6c435069460a55d9252d;hb=froyo-
release).

(end quotation)It seems clear these header files do include copyrighted
original source code that cannot be stripped of the GPL.

------
A1kmm
IANAL, but even I can see that it is inaccurate in at least several places: >
Google wanted to use a C library that was not licensed > under GPLv2 in order
to “keep GPL out of user-space.” > Instead of using glibc, therefore, it
created a new C > library called Bionic.

glibc is licensed under the LGPL; the LGPL does say you have to give users
some rights (e.g. to decompile your binaries), but you can link LGPL libraries
against code, make a binary, and not provide the binaries. Google could have
cut back glibc headers to only include the interface to Linux, licensed the
resulting library / header file set under LGPL, and then built a library that
uses that LGPLd library, licensed under whatever terms they want (within the
minor restrictions of the LGPL), and that would have been entirely within both
the spirit and letter of the LGPL.

> But even if you were to undertake this analysis and > segregate the
> copyrightable expression from the > non-copyrightable, it doesn’t change the
> fact that GPLv2 > covers the entirety of the kernel code and any >
> derivatives of it. Picking and choosing pieces of the > kernel code to
> include in a new library is creating a > derivative work, and, accordingly,
> GPLv2 would still > apply".

If Google successfully removed all copyrightable code from the Linux headers,
and included only the interfaces, then they wouldn't have to comply with the
GPL license for the kernel, because the whole point of the doctrine of fair
use is that you can do it without a license. It therefore wouldn't need to
license its library under the GPL.

If, on the other hand, the doctrine of merger didn't apply, and it wasn't fair
use, they would need a license to distribute the kernel headers. The GPL is
the only one available, so they would need to comply with its terms. Their
arguments that what Google did wasn't fair use seem to be more coherent,
although I haven't checked their claimed facts.

~~~
gonzopancho
The license of glibc is a red herring. The issue is google's copying of GPL
headers.

------
wzdd
The article makes the claim that inline functions and macros in header files
are copyrightable. This is plausible (based on what I've heard from lawyers).
It then goes on to suggest that applications which use Android's NDK could be
declared GPLed if there is a successful challenge to Android's cleaning of
header files. This seems far-fetched. Let's work it through. First, Google
would have to acknowledge that its headers were GPLed. Presumably this would
involve a court case. Brought by who? And on what grounds? Then, somebody,
perhaps the winner of the court case, would have to get the application
developer to acknowledge that their application was GPLed. This would
presumably be another court case. Again, brought by who, and on what grounds?
Assuming you did go through these heroic and precedent-setting court cases,
you would end up with the source code to a shared library, and you would have
to go through it all again to get access to the Java code or other application
components which are executed by interpreters. The whole piece reads like
Slashdot-esque fear-mongering.

The article then goes on to suggest that Google has "unlocked the kernel from
the restrictions of GPL2" and could "create a non-GPL'd fork of the Linux
kernel". I can't imagine how they imagine this could possibly be the case,
even if some legal challenge determines that they do have non-GPLed headers,
and the paper doesn't clarify.

------
aidenn0
1) This article claims several times that APIs are copyrightable. That is a
fairly bold claim to make, and would imply that any libc implementation for
linux would need to be licensed by whomever the linux IP holders are. If glibc
has not received such a license then it is in violation of the GPL, since it
is not released under the GPL.

2) There is the much less strong (and more tenable) claim that functions and
macros defined in the headers _are_ copyrightable since they are not a
necessary part of interacting with the linux kernel. Google can then become in
compliance by removing the offending code and re-implementing it themselves.
They could still be liable for damages but...

3) If someone were to sue Google for copyright infringement, they would not be
able to compel google to release the code to Bionic under the GPL. That could
be part of a settlement, but the most they could hope for in a court is to get
Google to stop distributing Bionic, plus receipt of monetary damages.

~~~
cyrus_
The point is that implementations are copyrightable and because Google did not
strip out macros and inline functions, it has not simply reimplemented an
interface but instead created a derived work.

------
ChuckMcM
[random: Gotta love this stuff when its submitted anonymously.]

Long snarky post edited down to the basic soundbite : Copyright is an evolving
area where the judiciary is trying hard to keep up.

Google, and other companies, pay people money to create software which, in
exchange for that pay (and free munchies etc) those people give complete
ownership over to the company. It is completely reasonable to expect Google to
do anything reasonable to limit the virality of the GPL's impact on what they
do, especially in a product that they charge money for and expect to make
serious coin on. Actions I would expect them to pursue are rewrites and
selective litigation.

------
oconnore

        "Google can now use the “clean” Bionic headers to 
        create a non-GPL’d fork of the Linux kernel, 
        one that can be extended under proprietary license terms."
    

No, Google can only write non-GPL'd programs on top of the existing kernel.
The kernel itself is GPL'd, regardless of whether the "clean" headers count or
not.

------
joe_the_user
I believe the entity that would have to bring any suit against Google would be
the Free Software Foundation or their representatives.

However, I don't believe the FSF would have an interest in having an interface
be declared copyrightable - just the opposite.

Most GPL suits are extremely forgiving. They give the party the option of
removing the code or making it available.

The absolute worst case scenario I could imagine given this is that Google
would be forced to make a "cleaner clean-room" implementation of the
interface.

The last thing I could imagine the Free Software Foundation wanting is a
demonstration that it is impossible to construct proprietary software that
_runs_ on Linux.

All this just has the feel of anti-Google FUD...

Edit: yes, gpl-violations.org seems to have done the last Linux I found of but
I don't think any Free Software Entity wants to be Oracle's stalking horse
against Google.

~~~
kkowalczyk
Nitpick: FSF doesn't own copyright to Linux kernel, Linux developers do.

But your main message is right on: Linux kernel developers have no reason to
sue Google for what at best is very minor issue.

