Matthew Garrett: Android, GPL violations and Google
A bit over a year ago, I wrote about how an incredible number of Android tablets on the market were in violation of the terms of the GPL. I've had rather a lot else to do since then so it's now awfully out of date - but taking a quick browse through the current stack of cheaper devices indicates that things aren't all that much better. We've got source code for some chipsets that were missing it before, but to compensate we've got a whole bunch of new hardware that's entirely lacking. It's all pretty poor, really.At the time, I wrote the following:
"(Side note: People sometimes ask why Google aren't doing more to prevent infringing devices. For the vast majority of these cases, Google's sole contribution has been to put Android source code on a public website. Red Hat own more of the infringing code than Google do. There's no real reason why Google should be the ones taking the lead role here, and there's fairly sound business reasons why it's not in their interest to do so)"
Factually speaking, nothing's changed. Each of these devices contains code owned by Google, and Google could absolutely take legal action against the vendors. Equally, so could Red Hat, Intel, Nokia and dozens of other companies who hold copyright on portions of the code carried on these devices, and so could thousands of individuals around the world. Nobody's obliged to enforce their copyrights, and in the absence of anyone else doing so it's unreasonable to insist that Google should do it.
However.
Google gives Android away. This seems like an odd thing for them to do, given that it's a significant engineering effort and costs a lot of money to produce. But remember what Android brings to Google - it's a platform with a well-integrated mechanism for distributing advertising to users. Scanning the market shows a huge number of ad-supported apps, and Google's getting money for every single one of those that gets shown. The more Android devices, the bigger the market for apps - and the wider their advertising reach.
In other words: unscrupulous hardware vendors save money by ignoring their GPL obligations. This lets them appeal on price, increasing the number of Android devices in use and increasing Google's profits. Google makes money off other people's violation of the GPL.
Could Google do anything to stop this? Yes. They could sue for copyright infringement, but that kind of thing's time consuming and awkward and any argument about the GPL always seems to end up as a big argument involving conspiracy theories. Instead, Google could attach some extra conditions to the Android trademark. Requiring that the trademark only be attached to GPL-compliant products ought to allow Google to take advantage of the existing well-tested mechanisms for seizing counterfeit goods, providing a direct economic incentive for companies to come into compliance. For added marks, they could restrict the adwords code to devices that use the trademark - if the vendor removes the trademark, applications depending on the adwords functionality would refuse to run and Google wouldn't make money off the infringing hardware.
Or, of course, they could just carry on making extra money as a result of vendors denying users the freedoms granted by the copyright holders. Although that sounds kind of evil to me.
Edit: You probably also want to read the followup post here.

This is my monthly summary of my Debian related activities. If you re among the people who
Dpkg and Multiarch
I had some hope to have a multiarch-enabled dpkg in sid for Christmas as Guillem told me that it was realistic. Alas Guillem got sick. We re in January and we re still not there.
While some of Guillem s commits in December were related to multi-arch, the size of his
<video controls="controls" poster="http://www.braincells.com/debian/images/jaldhar_jeopardy_howdy.jpg">
On my new
Today, I've spent some time on
(
So there are two servers; let's call them srv1 and srv2. Srv1
contains a bunch of subversion repositories, but these are to be
migrated to srv2. Since the repositories are not (just) used for
ascii-only files, they're fairly big (several tens of gigabytes,
altogether), so copying them from one server to the other would take a
while. In order to make sure this would happen quickly, we had already
copied them over to the new server, so that on the final switch would be
quick (an rsync that would copy over just the new done
transactions).
That final switch was today. Only I didn't know that instead of just
testing, the customer had already started using one of the repositories
(and they'd forgotten to remind me), so the subversion repository
suddenly jumped backwards in time. In addition, the new server wasn't
being backed up yet (at least not for the subversion bits), so restoring
from backups wasn't an option. Oops.
Luckily the solution is fairly simple. You see, fsfs stores each
revision in a unique file; that means that as long as nobody has
committed to the repository yet (which they couldn't, since system users
aren't the same on both servers, so the webserver didn't have write
permissions on the repository after the rsync), nothing is lost. One
only needs to manually change the repository so that whatever subversion
thinks is the latest commit, actually is the latest commit.
That information is stored in a file called db/current
inside the repository. What's in that file depends on the repository
version, which is stored in a file called db/format in the
repository. For versions 1 and 2, the format is a single line with three
space-separated values, of which the first is the last revision number
used in the repository. The other two are counters that are used to give
transactions unique names; and they, too, need to be up-to-date. For
version 3 and above, the file contains only the revision number; there,
the other two are derived from that instead of having their own unique
number.
Figuring out the last used revision number in an fsfs repository is
ridiculously easy:
Summary: It is important that we (the Debian community that relies on OpenPGP through
GNU Privacy Guard) stop using short key IDs. There is no vulnerability in OpenPGP and GPG.
However, using short key IDs (like 0x70096AD1) is
fundementally insecure; it is easy to generate collisions for short key IDs.
We should always use 64-bit (or longer) key IDs, like: 0x37E1C17570096AD1
or 0xEC4B033C70096AD1.
TL;DR: This now gives two results: gpg --recv-key 70096AD1
I used to recommend the GNOME desktop for simple users for two main
advantages over Windows:


