Android-powered smartphones have been creating quite a stir among the tech crowd lately -- and not necessarily the kind of buzz that Google was hoping for. Oracle sued Google for infringing several patents, and it also accused Google of copying Oracle's computer code, in violation of its copyrights. When a prominent blogger reported that he had found additional evidence that Google had copied Oracle's code, a flame war broke out. For example, this Engadget article reporting on the issue generated more than 750 comments, most of which brought more heat than light to the issue.
But there's more to this story than Google's "borrowing" of Oracle's intellectual property. The Android programming code is publicly available, and the increased attention has brought increased scrutiny. Recently, Ray Nimmer, a well-known copyright law professor, observed that there could also be a problem with the way Google used some key Linux software code, called kernel header files, to create a vitally important element of Android. In fact, the way that Google used these files creates a legal quandary for manufacturers of Android devices and many developers writing code and applications for those devices.
What did Google do this time?
Google built Android around Linux, which is an open source operating system licensed under the GNU General Public License version 2 (GPLv2). The GPLv2 is a "copyleft" license: it grants everyone the freedom to copy and modify the Linux code, but that freedom carries conditions, including the requirement that any modified software code and any works "based on" it must be made freely available to all. The very point of the GPLv2 is to make it impossible for anyone to take GPLv2-licensed code and make it private and proprietary.
Working with open source software thus demands careful attention to legal and technical details. I regularly advise clients on the proper use of open source software, and I understand well the difficulty of reusing code licensed under GPLv2, especially for developing proprietary software. I was therefore intrigued by Prof. Nimmer's explanation of the way Google had used the Linux kernel header files when it created Android.
The fact that Android is built on open-source Linux makes it attractive to many developers and users, but it presents some concerns for others. As Android has become more popular, clients have been increasingly interested in building applications that run on Android or even using the Android code in their own mobile devices. For many such clients, it is critical to their success that they can charge license fees for their products and keep their code secret to protect it from competitors. Google understood this, which is why it made Android available under the Apache Software License, a license that was much more business-friendly than the GPLv2.
But Prof. Nimmer's article raised questions about what Google had actually done, so I began to look at the Android code. What I found really surprised me: Google took a novel and quite aggressive approach to developing a key component of Android -- the Bionic Library. That library, a type of C Library, is used by all application developers who need to access the core functions of the Linux operating system. Google essentially copied hundreds of files of Linux code that were never meant to be used as is by application developers, "cleaned" those files using a non-standard and questionable technical process, and then declared that the code was no longer subject to the GPLv2, so that developers could use it without becoming subject to copyleft effect that would normally apply to GPLv2-licensed code taken from the Linux kernel.
Why does it matter?
My full analysis of the legal issues can be found here, but in short, I have serious doubts that Google's approach to the Bionic Library works under U.S. copyright law. At a minimum, Google has taken a significant gamble. While that may be fine for Google, because it knows about and understands the risks, many Android developers and device manufacturers are taking that same risk unknowingly. If Google is wrong, the repercussions are significant for the Android ecosystem: the manufacturers and developers working with Android would be incorporating GPLv2-licensed code into applications and components and taking on the copyleft obligations of that license.
What is potentially even more interesting is what happens if Google is right. If that is the case, Google has found a way to take Linux away from the open source community and privatize it. Perhaps the community believes it can rely on Google to "do no evil" with that kind of power, but can it rely on others to be so magnanimous?
This article provides information, not legal advice. The views expressed are my own individual views and should not be attributed to any clients.
_EXTERN_INLINE struct cmsghdr *
__NTH (__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg))
{
if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))
/* The kernel header does this so there may be a reason. */
return 0;
__cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
+ CMSG_ALIGN (__cmsg->cmsg_len));
if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
+ __mhdr->msg_controllen)
|| ((unsigned char *) __cmsg + CMSG_ALIGN (__cmsg->cmsg_len)
> ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))
/* No more entries. */
return 0;
return __cmsg;
}
So is it any wonder that this shill would be happy to spread FEAR, UNCERTAINTY, and DOUBT [FUD] about Linux or its derivatives? See -
http://www.networkworld.com/community/blog/lawyer-behind-android-infringement-claim-has-
Linus Torvalds did register the Linux trademark, but that is not a copyright on the code snippets.
That is true for a patent but not true for copyright or trademark. Registration does not, in any way, confer copyright. Registration merely announces to anyone concerned that copyright is claimed and the claim will be defended. Successful defense of the claim is the only thing that actually established a valid copyright, not the listing in the registrar. There are numerous instances where someone has not even claimed copyright until after an infringement has happened, won their claims in court, then registered their copyright as a notice of their property. The same is true for trademarks, the most famous and far reaching claim being for the cover art work for Peter Rabbit 50 years after Beatrix Potter's death. The publisher trademarked her artwork after the copyrights ran out because trademarks never expire.
SCO tried to claim copyright infringement based on headers in its suite against IBM. Although that issue has not been resolved, the judge upon see the "evidence" said is that all you got!? I haven't seen anyone other than some "journalist" who was employed by SCO in some manor, as she is listed as a creditor in SCO's bankruptcy give much credence to SCO's theory.
Google is trying to put a licence firewall between GPL-ed Linux and the rest of Android, including code running on Android.
This is essentially what glibc does which is why commercial programmes can run in Linux. These programmes link to glibc via LGPL which places no copyleft constraints on users of its api.
So the real question is why is glibc privileged in defining "normal system calls" to Linux (http://lkml.org/lkml/2003/12/4/239) and what are the legal barriers to Google making its bionic library LGPL-able just like glibc? Why is glibc privileged in providing "normal system calls"?
I think it is likely that Google failed to strip copyrightable content when generating Bionic. But it is very arguable that since bionic library provides a clean demarcation between the underlying Linux in the Android kernel and programmes which make calls to Linux, that any calls to bionic are also "normal system calls".
As such they would be exempt from the GPL requirements in the kernel source.
Of course it does not help that Android gives the impression that it is forking the Linux kernel in a proprietory way...
Leo
2 NOTE! This copyright does *not* cover user programs that use kernel
3 services by normal system calls - this is merely considered normal use
4 of the kernel, and does *not* fall under the heading of "derived work".
What app developers are doing would be use. Arguably what google might not be, but they do distribute the source. If the Google bionic mechanism were found non free the exemption about would still apply to android application developers.
Now an author (like you) who wrote code prior to that clause could argue that by adding that clause to the COPYING file Linus was asserting ownership, an ownership he doesn't have, and tell him to distribute your code under a pure GPL license. He would probably cut your code out but if he didn't I think you could argue intentional infringement on his part.
But no, something written into a legal document isn't just an opinion its part of the very contract.
Those who blessed the glibc approach had no authority to license the header files under any special terms. The kernel header files contain content they did not write and the GPLv2 does not permit or authorize relicensing (see section 6).
Linus' argument reduces to "fine if I do it to other people's code but not fine if you do it to other people's code".
Linus' estoppel argument doesn't work. The whole point of copyright is that third parties can't waive it. Linus statement that he will allow use of these files acting as estoppel doesn't work. Nothing Linus says can waive the copyright rights of every single author who license their code under only the GPLv2. Linus both ackwnowledges this and denies it in the linked page. (http://lkml.org/lkml/2003/12/4/239) It might prevent Linus from making a contrary argument and maybe even those who contributed code after it was added, but it was added after significant expression was already taken from the kernel headers.
If that expression is copyrightable, Linus waiver fails. If that expression is not copyrightable, Google wins.
Say there are two projects A and B, both covered by the GPLv2. I can take code from project A and add it to B if I want. The GPLv2 requires that this be allowed. But if the author/maintainer of project B has contaminated the license in any way at all, who grants permission for the change? I can't do it -- I didn't write the code, I'm just taking some of it from one project and putting it in another.
If Linus has made any modification or exception to the license at all, then GPLv2 code cannot be added into the project by anyone but all of its authors jointly. That would also mean Linux code couldn't be used by any other GPLv2 project because the authors of that project have only consented for pure GPLv2 works as derivative works.
There is simply absolutely no possible way that could be right. Linus' estoppel or consent by notice arguments do not work with copyright law. (They could work with pure contract arrangements, but that's not what we have.)
I think the better argument is scènes à faire (or merger doctrine). The headers are a component that provides functional access to the rest of the work's functions. If they were covered under copyright, the copyright holder could hold a functional right. Copyright only applies to one way of doing a certain thing when there are a large number of equally-good ways to do that same thing.
Paramount can own Star Trek because there are any number of ways, some better than Star Trek, some worse, to tell a story about humans of the future who travel the stars looking for alien life to contact. The Linux kernel developers cannot own *every* way, or even the best way, to make applications that call into the Linux kernel.