Does Google's Android violate the GPL? This bold claim is being made by Edward Naughton, and was picked up here and there across the web. The problem seems to be that Android's Bionic, a glibc alternative, supposedly violates the GPL by stripping the Linux kernel header files of all comments and other extraneous information and relicensing them under a more permissive license so that non-GPL programs can be written. Bradley Kuhn, former FSF executive director and expert on GPL violations, believes the claims are way overblown.

I was hoping to avoid having to comment further on this problematic story. I figured a comment as a brief identi.ca statement was enough when it was just a story on the Register. But, it's now hit a major tech news outlet …
— Bradley M. Kuhn

I'm not sure what your project is designed to do, so I don't have an opinion about how it stands regarding the GPL. However, I've talked with our lawyer about one specific issue that you raised: that of using simple material from header files.

Someone recently made the claim that including a header file always makes a derivative work. That's not the FSF's view. Our view is that just using structure definitions, typedefs, enumeration constants, macros with simple bodies, etc., is NOT enough to make a derivative work. It would take a substantial amount of code (coming from inline functions or macros with substantial bodies) to do that.
---

This might also explain why no coders have come forward to complain or object to it. (^;)

If headers only include structs and function calls including it the license of the header does not effect the rest of the work. In the USA atleast.

Note those items are still copyrighted by the first copyright holder.

Now if the headers contain macros and inlines copied across they are active code. No different to linking a .c file into your binary that is GPL if you use them.

Few legal problems stripping of copyright notice very much like Novell did with BSD and paid a high price. 2 it was a program that processed the data. Legally if program processing the data has not been ruled if that resets copyright.

Yes if I type a new copy of the struct and the interface functions even if it looks the same since I typed it the copyright is mine. Legally is a computer program allowed to also do this. Has data processed by a program changed copyright.

Because this does open up some scary facts if it does.

One of the issues being argued over in the Orcale case against Google on java is the use of decompliers and its effect on copyright.

Technically Orcale lose and we might be legally allowed to used a decomplier to pull programs to bits and rebuild them under a different license.

AFAIK, header files are NOT copy-writeable. They are similar to book titles.

As for machine generated code, you still start with something that is copyrighted and make a copy of it, at least into memory. There is also the issue that the code is still essentially the same. While it may differ a little, the vast majority of it will be the same in structure making it a derivative work.

Well in general. While there is no issue here, the copyright status of header files is not that simple.

Header files are supposed to be interface descriptions, and interfaces can not be copyrighted.

On the other hand, C and C++ makes no distinction between source files and header files, and it is very easy to put non-interface code into the header files, inlined functions, templates and comments are all copyrightable, so you can not make a blanket claim.

Still this is rather stupid. The Linux system-calls are not only header files they are the published APIs for the operating system, they are published for the very purpose of being used by all types of software.

One thing strikes me as odd though: Why did Google feel the need to change the license header? The very fact that makes it legal for them to do so, is the very fact that makes it completely unnecessary.

Linus calls these claims bogus. Userland programs are not derivatives of the kernel, there is no copyright violation, and indeed userland programs are *expected* to use the kernel header files in order to interface with the kernel.

Way back in the early days of Linux, shortly after Linus Torvalds switched the kernel from his own "non-commercial" license to the GPL, he also added an important clarification to the kernel's license. In the COPYING file at the top of the kernel tree since mid-1993, there has been a clear statement that Torvalds, at least, does not consider user-space programs to be derived from the kernel, and thus are not subject to the kernel's license:

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".

Kuhn's argument is as unsatisfying as he says Naughton's is. Neither is a full analysis. All that Kuhn is really saying is that Naughton hasn't fully analyzed this. He isn't actually saying that he's wrong, just that he might be, or that he might only be partly correct. But neither has he done any analysis. In fact, his own arguments are mere speculation.

This does need further work. But for now, it doesn't look good for Google.