GPL Gets Its Day in Court in Israel 232
Posted
by
ScuttleMonkey
from the never-fun-to-break-new-legal-ground dept.
from the never-fun-to-break-new-legal-ground dept.
MadFarmAnimalz writes "In what appears to be the first court test for the GPL in the Middle East, Alexander Maryanovsky, the author of the GPL licensed Jin Chess Client is taking IchessU to court for violations of the GPL license."
Re:Right.... bit of clarification (Score:5, Insightful)
And in the license itself: "For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable."
IMHO, that means Windows API = ok, Java API = ok,
And that makes sense. Otherwise I could just build all of my app in my "MainApp API" and GPL my "StartMainApp()" function call...
Re:Right.... bit of clarification (Score:5, Insightful)
Nope.
Only part of the client source code is downloadable, not the whole; this is a violation of the GPL. Also, the iChessU has an EULA which violates the GPL by placing new restrictions on how the code may be used.
The bad faith negotations accusation may be an overreaction but it's hard not to think this when iChessU initially wanted to license JIN but backed out when it appeared too expensive for them and then proceeded to use it anyway.
This is not an overreaction but a devloper fighting to prevent a third party assuming legal control of that developers work.
Re:No it's not (Score:1, Insightful)
Then what does it use? Pipes? Temp files? Squirrels? Of course the closed source driver communicates directly with the stup and the stub communicates directly with the kernel. The Stub is a technical trick which allows NVidia and ATI to deliver one precompiled module even though the kernel constantly changes in ways which would require a recompile from source. The stub has absolutely no legal relevancy.
Re:In a way, this is very lucky timing for GPLv3 (Score:5, Insightful)
generous offer (Score:3, Insightful)
Re:Great. (Score:2, Insightful)
Re:GPL doesn't need to be tested. (Score:5, Insightful)
That is not a restriction that GPL adds: you never were allowed to do that in the first place. Suppose the code is not under any license, then standard copyright law applies. And copyright law does not let you copy that code to your code AT ALL.
Re:Doesn't matter (Score:3, Insightful)
That's a pretty extraordinary claim, given that the graphics card drivers should be some of the highest-performance ones in the system. I would have thought that they, more than anything else, would require direct linking. Anyway, do you have a citation that supports your statement?
nVidia clarification (Score:3, Insightful)
The Law of the Land gives you only very limited permission to copy a program (see "fair use" or "fair dealing"), and would ordinarily take a dim view of you distributing copies. The GPL gives you permission above and beyond your fair dealing rights (which are determined by the courts) to do certain acts dependent on certain conditions. One of the permissions granted by the GPL is to make and distribute copies, gratis or for money, as long as you ensure that everyone who receives a copy of a program from you receives the same permissions as you (hence the requirement at least to mention the GPL), and can exercise them meaningfully {hence the requirement to make source code available).
The nVidia drivers are supplied as a closed-source binary blob, which is distributed under a restrictive licence; and a GPL wrapper which implements an interface between the kernel and the blob. The addresses of things in the Linux kernel are subject to change from one version to the next; but you can find out what is where from files that are generated during the compilation of the kernel. The addresses of things in the nVidia binary blob are also subject to change from one version to the next; but only nVidia know what is where. So nVidia provide the source code for a wrapper that interfaces between the kernel {where addresses of functions can be determined from system files} and the binary driver {where addresses of functions are hard-coded into the wrapper}. nVidia can legally do this because they own the copyright on both bits: the Law of the Land does not prevent a copyright holder from making derivative works. The GPL grants you permission to enjoy, study, share and adapt the wrapper. In order for it actually to be any use, however, you need the binary blob (which, being pure x86 machine code and talking only to graphics hardware, does not depend on a particular OS). The combination of binary blob and GPL wrapper constitute a derived work. You are right that the GPL does not grant you permission to make such a derived work. However, that's irrelevant. The Law of the Land grants you permission to make this derived work, because that is a necessary step in making use of something you legally own -- and therefore constitutes fair dealing.
Once you have combined code covered by two different licences, you are bound by both licences. The GPL demands that you at least offer to distribute source code if you distribute anything, whereas the nVidia licence does not grant you access to the source code and would not let you distrubute it even if you had it. So, unless you live in some jurisdiction where the Law of the Land grants you access to the source code, the only way to satisfy both the GPL and nVidia licences is not to distribute the code produced by combining the GPL wrapper with the closed-source blob.
For what it's worth, I think nVidia are scumsuckers and I hope their binary blobs are reverse-engineered. But the law seems to be on their side.
Re:Right.... bit of clarification (Score:3, Insightful)
How I would fight the GPL (Score:3, Insightful)
If I wanted to write a program that integrated with GPLed software but did not want release my code under GPL, here is what I would do.
My strategy, instead of looking for loopholes in GPL's terms or figure out what is permitted, would be to completely avoid getting bound by the license. If I do not accept their license, then no lawyer is going to be able to make arguments about whether I complied or not. Don't fight on their terms. Don't let any of the text in their license be admissible or relevant.
The key to doing this, is to forget that the code you want to integrate with, is GPLed. Forget you have any extra rights that you might exploit. Assume that the code you're depending on has the tightest, most restrictive and hostile license that exists. Handle integration with a GPLed chess program, the exact same way that you would handle integration with Microsoft Excel. Ask for no favors other than whatever is allowed by copyright law.
To do that, the two major hurdles are:
If you can accomplish those two things, you avoid the license, and therefore it doesn't matter what kind of license it is, and it doesn't matter whether or not the terms of that license would permit whatever you're doing.
I'm not 100% sure what the legal definition of derivative work is, but I do know that you find out by asking your own lawyer instead of FSF's lawyer. As soon as someone at FSF starts talking about what they permit, you know they're talking about their license instead of copyright law. And you need to concentrate on copyright law.
One thing you can infer from the market overall, is that calling someone else's program does not make yours a derivative work. Even if you call the other work in a way that your program 100% totally depends on it and has zero worth without the other work, that doesn't make your program a derivative work. How do we know/infer this? From the proprietary software market. In spite of various projects like WINE, it's pretty safe to say that no Windows applications have any use outside of MS Windows. They simply don't run. If WordPerfect for Windows were a derivative work of MS Windows, don't you think Microsoft would have sued WordPerfect in order to squash the competition? Of course they would have. So don't worry about calling APIs.
And it doesn't matter how public the API is. Especially in the DOS days, there were all sorts of programs that did very intimate things to MSDOS's internal structures (e.g. disk managers, many many TSRs, etc) and nowdays on MS Windows you see some of this with the AV products. But surely McAfee's AV program is not a derived work of MS Windows. So don't worry about calling or the intimacy of calling. To avoid being a derivative work, just make sure you don't use any of the other guy's code.
Packaging. This is the tricky one. It's hard to sell a program that doesn't work on its own. The amusing thing here, is that with Linux, there are all sorts of packaging systems provided by the distributions, such as apt-get or emerge, that will solve this for you. If I wanted to write a proprietary program for Gentoo that depended on some GPLed stuff, it would be really easy to to just ship an ebuild that tells portage about the dependency, and it would get installed automatically when the user wanted to install my program. Then I wouldn't have to ship any of their stuff.
MS Windows (and MacOS AFAIK) doesn't have any sort of automatic generic get-and-install-all-the-dependencies program. (That makes it actually harder to defeat the GPL on Windows than on Linux.) Of course, you can probably just ship your Windows app with an installer than downloads and installs the dependencies, but support and maintenance would be tricky. And it would be