Google's Android faces a serious Linux copyright issue
fosspatents.blogspot.com
fosspatents.blogspot.com
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...
"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...
Seeing as this is exactly what GNU's very own libc does, I don't see how it could not be allowed.
I wonder about simply using generic POSIX headers. I realize this would be utterly complicated (knowing C's idea of "modularity"), but I suspect it could sidestep copyright issues?
http://lkml.org/lkml/2003/12/5/162
(in general, the thread was about kernel modules - this message explicitly mentions user-space)
Most non-GPL userspace programs use glibc, which is LGPL(and therefore can be linked by any license).
If Google copied the headers verbatim, then created a non-GPL licensed wrapper around those headers, that is a GPL violation.
He actually makes a pretty decent case for this.
> 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".
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.
> 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.
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
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.
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.
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.
Linus disagrees that the Linux headers are not copyrightable: http://lkml.org/lkml/2003/12/5/13
Do Google strip out the inline functions? I don't think even the most ardent Google defenders can say that inline functions are not copyrightable.
>If I copy GPL-licensed code into my BSD-licensed library, none of my code has to be relicensed.
If I now want to use your BSD-licenced library surely I am bound by the terms of the GPL, since it includes GPL code. That parts that you wrote are still under the BSD, but the restrictions on use of the overall library will include the GPL terms. Otherwise just inserting a single line of BSD code into a fork of a GPL project would be enough to bypass the GPL.
>Completely and egregiously wrong. Unless these programs are actually copying parts of the kernel into their source, they are not derived works.
So linking proprietary binaries to GPL libraries is legal? Everything I have heard has indicated the opposite, that linking to GPL libraries makes your binary into a derived work (the reason the LGPL exists). I would be very interested in knowing if this is the case or not.
>According to the author's reasoning, glibc is also an illegal derivative work of the Linux kernel
Yes, this issue does seem contradictory.
>all built on the incorrect assumption that running proprietary software on a Free kernel/libc is illegal
It appears to me to be built on the assumption that Linux header files are copyrighted and under the GPL.
Your comment is contradicting the understanding that a lot of people have of the GPL (including presumably Richard Stallman himself, who saw the need to create the LGPL).
Wrong. You can copy BSD-licensed code into your GPL-licensed library with no problem, but GPL-licensed code copied to a BSD-licensed library will have problems. GPL-licensed code into a BSD-licensed library prohibits redistributing the resulting work under BSD.
> Completely and egregiously wrong. Unless these programs are actually copying parts of the kernel into their source, they are not derived works.
You've missed the point. If the Google de-copyrightizanator (WTF! Apple's spell check did not flag de-copyrightizanator!) has failed, and the header files Google shipped for third parties to use do in fact contain copyrighted code under GPL, then there may indeed be a problem for third parties. Headers files often contain more than just the specification of an interface (which is probably not copyrightable). They often contain actual code, which is copyrightable. That code could end up in applications, in which case they would in fact have a serious GPL problem.
You say "wrong", but then argued something completely different from what I claimed.
I said: "If I copy GPL-licensed code into my BSD-licensed library, none of my code has to be relicensed."
You replied: "GPL-licensed code into a BSD-licensed library prohibits redistributing the resulting work under BSD."
These statements are regarding completely separate concepts.
If you copy GPL code into your BSD library, and then distribute the resulting library, you MUST distribute that version of the library under GPL. You can continue to make the version that does not contain any GPL code available under BSD if you wish.
If you copy GPL code into your BSD library and do not distribute it, then GPL is irrelevant.
If you copy code from one library into another, then the combined work uses both licenses, but the code retains its original licenses.
Using the example of copying GPL code into a BSD library, the entire library (and any tarballs, binaries, etc) are covered by both licenses, but my code (the BSD code) stays BSD. It's not relicensed.
Not really. A license is an agreement between the copyright owner and whoever is seeking permission to do something that falls under one of the exclusive rights granted by copyright law to the owner of the copyright.
The claim is not that running proprietary software on a free kernel is illegal. The claim is that by linking to Bionic, which may violate the GPL, the proprietary software might become "derived works" of the kernel.
The second statement is not a strawman -- that is his actual (implied) argument. Otherwise, the whole thing about Bionic is completely irrelevant. Bionic's license status only matters to client software if licenses are assumed to propagate across the library boundary. If running proprietary software with a Free libc is OK, then a GPL'd Bionic is no risk to proprietary software linked against it.
The latter part of your statement doesn't follow from the former, since glibc was written from scratch by its GNU authors. If half of glibc headers were just stolen from the kernel tree, your argument might hold water, but they absolutely were not.
glibc is a legal implementation of a Linux-compatible libc. Since it's LGPL, one can legally link non-GPL code against it. The author's suggestion that the only way to make things OK is to switch to glibc is kind of farcical, since it would appear that creating a new implementation of Bionic whose licensing status is on par with glibc would suffice.
In his comments on this site he has stated that the reason glibc is available under the LGPL is that the headers it uses were added to glibc by the kernel maintainers who held the copyright to them[1][2].
I've no idea if this is true, but it seems to be the crux of the issue, if indeed the headers are covered by copyright as Linux Torvalds believes (unless we are to assume that glibc is also in violation of the GPL). Perhaps somebody familiar with GNU and glibc knows if this is the case.
[1] http://news.ycombinator.com/item?id=2337064 [2] http://news.ycombinator.com/item?id=2336690
Either you're not responding to my comment, or you are misunderstanding me very badly. This is not what I'm saying in the least. I'm saying that if Google were to create a legal interface to the kernel, they would be in the clear. Two apparent ways to do this are (1) have someone who owns the copyright to the kernel header contribute the appropriate portions of your library and give consent to whatever license you choose, or (2) do a clean room implementation of the interface.
Google would most likely have to do the second, but they absolutely could do so. Apparently they think they've come up with a third, but it may not be good enough, which leads us to the article that spawned this discussion.
So you are saying the licence used for Bionic doesn't come into play if Google do a "clean room implementation" of the headers? If they do that, they can use any licence they like, since they are not using any copyrighted parts of the kernel.
This does leave me unsure on another point though. How does the GPL prevent the linking of a GPL library from a non-GPL binary? One can distribute the binary without including the library, so you aren't distributing it, and just using the headers from the library is apparently OK, as long as you do a clean implementation and don't use headers containing any inline functions. What legal mechanism does that leave for the GPL to prevent linking by non-gpl works? As I understand it the GPL is entirely based on copyright. If I never distribute the library in question, I never have to agree to the terms of the GPL since I never copy it (putting aside personal use of the library).
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...
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.
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.
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.
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.
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.
During all those years that Linux has been around, no one other than Google has tried to take this kind of material from the original kernel headers and publish it under any license other than the GPL. And no one has tried to do an alternative glibc. I guess what someone would do is take glibc and fork it on LGPL terms.
You can build libraries if you like, but you can't just put header code under a different license unless you're the original right holder or have the original right holder's consent.
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.
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.
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.
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.
whoops..
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.
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?
However, if I buy it, then you have to provide me with the source code (upon my request). The source has to be licensed under a licence compatible with the GPL, which means that I have the right to modify the code and distribute under a compatible licence. Therefore, I can resell your software, or give it away for free.
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.
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.
It's worth reading the original instead of the above linkbait.
[1] http://www.brownrudnick.com/nr/pdf/alerts/Brown%20Rudnick%20...
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.
Oracle on the other hand wants either to hurt Android, or a (preferably large) piece of the pie.