Slashdot Mirror
GPL Gets Its Day in Court in Israel
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."
There is an open source chess client called JIN licensed under the GPL.
This is an executable and front end chess client.
This has been extended by iChessU to support a closed source DLL which adds new functionality (notably video streaming between players).
The source code to the Expanded client is available and providing you have the closed source binary DLL, you can run the newly compiled program.
Isn't this like me releasing a GPL program which is linked to the nvidia or ATI blobs?
Hell, isn't it similar if I write a GPL application which uses the Windows API?
I personally feel as though this is an overreaction, the ichessu site does not hide the fact its based on JIN and offers sources, or am I wrong and this is infact a genuine GPL violation?
liqbase
Isn't this like me releasing a GPL program which is linked to the nvidia or ATI blobs?It isn't, because ATI and NVidia do not link to the kernel. The portions of the NVidia and ATi driver that *do* link directly to the kernel (also known as the "kernel stub"), are indeed GPL. What happns, is the closed source X driver communicates to and from the stub indirectly, not via linking.
It's actually just a different DRM/DRI implementation, which nearly all X drivers use nowadays.
Note in this case DRM does not mean "Digital Rights management", it means "Direct Rendering Manager"
It's great that we will get the benefit of this ruling during the year when GPLv3 is being written. This sort of thing provides great suggestions for what should be clearer or worded differently.
Please help publicise swpat.org - the software patents wiki
Is it just me, or does $4k sound very cheap for full rights to the source code?
MOD ME UP!!!!!!!!!!!!!
To have a right to do a thing is not at all the same as to be right in doing it
Here we go again... GPL doesn't need to be tested in court. GPL doesn't restrict you from doing anything. The only thing GPL does is to allow you to do some things with copyrighted work - such as, under certain circumstances, distribute said work even if you are not the copyright holder.
What's being "tested", if anything, is copyright laws. And I believe that we all can agree on the fact that they are already, if nothing else, fairly tested in court.
May we live long and die out
Pipes, temp files, sockets, none of these are covered by the GPL. The GPL covers explicitly *linking only*. If a GPL'ed piece of software could not communicate with a closed source piece of software over a socket or pipe, the Apache web server would not exist.
To be specific - I am pretty sure the drivers use either a UNIX socket or a named pipe.
Yes, it does. If the developer wanted the source code to be able to be used in commerical non-free applications then he would have released it under the BSD licence.
...and that is all I have to say about that.
http://jessta.id.au
I happen to know Hebrew. Some more information from the Hebrew documents is the matter of money; the Jin programmer is requesting 20,000 NIS (about $4500) as 'damages' (for the violations made so far). This is perhaps an initial offer for settlement. Note how the $4500 is just higher than the $4000 he initially wanted from them (which seemed more than fair to me, personally).
In the lawsuit, it is mentioned that in Israeli law (which I cannot confirm or deny, I have no idea) the minimal fine possible for this type of offense is 10,000 NIS (about $2250).
I can translate other parts of the Hebrew documents if anyone is interested.
Although the content is currently the same, the real URL of my Jin website is http://www.jinchess.com (could an editor please fix it - I think it can handle the residual slashdotting). I'll now get back to reading everyone's comments and reply where I can :-)
The reason for this "problem" or "benefit" (depending on your philosophy) is very simple. Dynamic linking is done against an interface, and interfaces cannot be copyrighted because they are the key mechanism for interoperability. There are decades of case law enshrining that principle. (Don't forget that we benefit hugely from interoperability too.)
The GPL is a copyright license (not a EULA), and it cannot claim copyright on the interface to which separate applications are coded. As a result, the GPL has no copyright mechanism for "bridging the gap" between a dynamic library file and an entirely separate application which uses its interfaces. (Otherwise SCO too would have a case that all Linux apps are derived works of Unix, just because they use the same interfaces --- fortunately it's not so.)
And it gets worse (or better). The fact that such an application can be made to work against *ANY* other dynamic library that satisfies the same interfaces reinforces the exclusions for interoperability. Add to that the fact that no COPYrighted material ever actually gets copied, and you see why GPL enforcement is limited to two clear cases:
- code inclusion by static linking -- the new source code does not contain any GPL'd source code within it, but the distributed binaries physically contain GPL'd code brought in by the static linkage -- so that the copyright laws which cover copying can be applied (in this case the GPL license transfers by the GPL'd code being physically bound to the new code and distributed along with it).
Both of the above cases are quite clearcut to apply, and hence supposedly safe.The other major case (dynamic linking, in which no copyrighted source code has been used and no copyrighted binaries are included) is shrouded deep within the darkest clouds of uncertainty, since there is no legal mechanism by which the copyright can transfer to mere client code which is coded to a non-copyrightable interface.
"The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra
I've been watching the kororaa project for a while, ever since we did one tandem session with XGL and OS X on two machines, watching XGL rule - especially in the video across cube faces demo. But a few weeks later, the developer announced that he's stopping Kororaa because of GPL issues with properietary drivers. And here's a reply by the FSF.
Now, the point to note here is that GPL is redistribution license. The way the nVidia folks handle it is to give the user some code, a binary blob and effectively tell them to build it themselves. The code they distribute does not link to the Linux kernel *yet*, while the binary blob is the closed source bit. Now, what the user does is to link them all up and there you go - which is not the distributor's fault. And this works because they are not redistributing any code that is copyrighted by a Linux kernel author (for example laf0rge).
The whole model makes the user violate GPL in principle, while the distributor (i.e nVidia) is in the gray area of legality. This is of course, my understanding from following up all this (and then had an argument with a paralegal @ work about GPL).
But I could be wrong you know ...
Quidquid latine dictum sit, altum videtur
>> Why not some formal law language with clear semantics and syntax?
:P
... and that of course would not be in their interests.
Several people have written objections to youe suggestion here, but computer-based solutions are easy to find if you use a reductionist approach and don't try to do *everything* mechanically.
The simplest and most powerful approach by far is to apply formal semantics by case, not by generic mathemetics: For each area of legal engagement, a large number of highly specific case rules are defined and given a priority to define the order in which they are applied, with each one capable of matching only one very narrow situation. Separately from this you define a set of legal outcomes (independent of the case rules!!!), and causal links are only then drawn from the case rules to the case outcomes.
This can be made as deterministic a system as you like, merely by narrowing the scope of each case rule. Needless to say, if no case rule matches then the case pops out of the bottom to be handled by a human.
This addresses the ambiguity problem by each case rule being extremely specific, and allows lawyers to enter the loop for unmatched cases given by hard or undefined problems. It addresses comprehensibility by the public by allowing a worm's eye of the problem, one case rule at a time, and by allowing your own computer to "scan the law", which is otherwise impossible unless you practice law yourself.
Of course, anyone who has worked in AI or expert systems will recognize that the above is just a logic system, only expressed in a way that doesn't blow the mind. Well, that's good.
There's always a way, if you want to find one. The trouble is, such a mechanism would require endorsement from the legal profession
"The question of whether machines can think is no more interesting than [] whether submarines can swim" - Dijkstra
That's not right...intentions have nothing to do with it.
You can license your code any way you want. If you want to license part of it as gpl, write a dll that is meant to work with your program only, but license it in a proprietary form, than release that stuff together with only the source code for the part that talks to the dll, you're fine. RMS would probably show up on your door holding a bat, but his lawyer won't be with him.
The license limitations don't limit what your gpl code can do, they limit what people can do with gpl code. So, if someone grabs the source code to a dll, and dynamically links to that with their non-gpl-compatible-licensed program, they are in violation of the gpl license for the dll, which doesn't allow that. However, if you're writing gpl code, you can link it to whatever you want, as long as the other license allows that. If the other license says you can't link it to gpl programs, you're screwed, but API's usually allow you to link to them, because they'd be useless if they didn't.
Warning: Opinions known to be heavily biased.
First point, the GPL does not forbid anything. It is a licence -- it only gives you permission to do something you would not ordinarily be allowed to do.
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.
Je fume. Tu fumes. Nous fûmes!
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
As copyright owner of this comment, I authorize everyone to defeat any technological measure which limits access to it.