Vidomi GPL Violation Case Resolved 189
Andy Tai writes: "The Vidomi GPL violation case, previously mentioned at slashdot as the "first legal test of the GPL", has been resolved without going to court. Vidomi has split their program into two programs and released the source code of the encoder, which links to other GPLed libraries, under the GPL. The FSF has approved the resulting arrangement as compliant with the GPL." See the original story.
splited? (Score:2)
Re:Yes it is (Score:2)
Re:Discovering GPL violations (Score:2)
These comments assume that the people who work on the proprietary source code are unethical. How do you catch a violation?
The truth is that companies do not steal the GPL code, but the software developers do. Sometimes it is accidental, however. For example a tool may have been developed for internal use and later sold. Alternatively, people who used the code may cycle out of the company before product release, thus reducing visibility into the licensing issue.
If a company learns about an infraction, it is vulnerable to a large lawsuit unless it tries to fix it. If it tries to hide it, then the company is vulnerable to a larger suit and those involved in the conspiracy may face jail or personal fines. There is incentive for them to play nice.
Re:Discovering GPL violations (Score:2)
Re:Two words: (Score:2)
What's really going on.... (Score:2)
Mr. Moglen, the legal counsel for the FSF, was not retained by Vidomi, AFAIK. When I first emailed RMS for help in enforcing the GPL, he referred my message to Moglen, asking him to help as possible. Mr. Moglen was actually quite helpful in explaining the GPL issues to the people at Vidomi on our behalf, and negotiating a manner of usage that was compliant with the license. The FSF was thus quite helpful in rectifying this issue, so please don't belittle their efforts.
The proprietary encoder, GPL decoder, and the overseeing application are all running in separate process spaces; the IPC mechanism supposedly consists of window messages designed only to smoothly modify the visibility and position of the different application's windows. I have not had a chance to verify this in the source, but checks with DUMPBIN and HandleEx would appear to confirm that neither static nor dynamic links between proprietary and GPL code are taking place. Asserting that proprietary and GPL components of the package are reasonably a single program is a much harder sell now that they have been separated technically (process isolation) and functionally (player vs. encoder).
Regardless of whether I like my software used as part of theirs or not, the issue is compliance with the GPL, which is only concerned with the software itself and not the ethics of its authors. Any further attempt to attack the company at this point is probably unproductive and less likely to succeed. If you think the situation is still untenable, I suggest you make use of the code they have just added to the GPL pot, and attempt to outcode them!
Did I mention I hate dealing with licenses? Don't underestimate the influence of the FSF in providing a standardized license.
P.S. I just released more free stuff at virtualdub.org in celebration.
Re:Discovering GPL violations (Score:4)
To use a real-world example: Thousands of commercial, proprietary, closed source software packages were distributed linked to the Motif libraries. Then LessTif was released under the GPL; this did not force all Motif-based programs to be licensed under the GPL. The fact that Motif program "Foo" happens to be functional if you replace Motif with a GPL library is irrelevant, since Foo is not distributed as linked with LessTif. The binary compatibility does not make Foo a derivative work of the GPL code. If LessTif offered a feature *NOT* in Motif, Foo could not legally use it without becoming a derivative work of the LessTif, with all that entails, but as long as they stick to distributing based on Motif Foo is fine, license-wise.
----
Re:Discovering GPL violations (Score:2)
1) go read about automata and regular expressions, and build your own parser.
2) go grab the first regex engine for which you can find the source.
I think many people would choose 2. Lazy and dishonest people may not check whether they are violating the rights of the copyright holder, or may intentionally disregard these rights. The company didn't mean to do anything wrong, but they don't even know this is happening. The guy gets fired eventually (hopefully all such assholes get fired eventually) and now nobody at the company knows about the violation, until someone discovers it accidently.
If you could watermark in such a way to make it easier for the dishonest, unethical programmer to use someone else's code (maybe they'll come across something with a BSD license) than remove the watermark, then you've protected your rights as the copyright holder. Honest, ethical programmers don't need to sweat the watermark issue, and encounter no additional barriers to assuming ownership of a copy of your code -- just as you desired. Of course, I have no idea right now how to make such a watermark.
-Paul Komarek
Re:Discovering GPL violations (Score:4)
I can see why you use the term "infect". But "protect" would work just as well, as would "enhance". I expect that you use "infect" because you have a bias, probably one that you copy from other people. If this is the case, you might consider reading about copyright, and engaging your brain before opening your mouth (or typing =-).
Screw right or wrong. Simply put, the company isn't meeting it's obligations if it doesn't make it's best effort to prevent this sort of thing. They accepted those obligations when they assumed ownership (not copyright) of their copy of the library's code.
I really don't understand why you're picking on the GPL with this scenario. I expect that LGPL'd libraries infrequently switch to GPL. It seems much more likely that a commercial vendor would require a a new license fee for every version they released, regardless of whether you get anything more for your money.
For example, consider the mozilla/netscape split. Mozilla ended up recreating everything from scratch, because some of Netscape's code was integrated with closed-source products. That sounds like a much worse "infection" than your infectious-GPL example. At least in the LGPL->GPL example, one could continue using the LGPL'd code if one wanted, because one *owns* the code.
If you ever create anything worth owning, I expect you'll come to appreciate the purpose of the GPL and LGPL, and quit acting so high an mighty about your decision to disagree with them on an ideological level. You'll might even come to agree with them if you ever wish to own something you created after signing an intellectual property release for your employer.
The GPL and LGPL are well concieved licenses, and were produced with legal advisors. They are *not*, as you claim, ridiculous.
While not a win for the GPL... (Score:5)
Re:Can we learn a lesson from the Adobe debacle? (Score:2)
--
Can we learn a lesson from the Adobe debacle? (Score:5)
So, putting 2 and 2 together, why can't the GPL be enforced in the same way? The lawyers get a cut, and the GPL gets enforced without the FSF or anyone else spending a penny.
--
Re:Discovering GPL violations (Score:2)
What if someone makes a library that's indistinguishable from libreadline, and distributes it with LGPL, BSD, or some other similar license. Then suppose someone distributes a closed source program that uses this libreadline clone. All legal right? But what if someone goes and installs GNU libreadline on a system that's got this closed-source program?
The fact is, RMS's belief that GPL can infect even software that only dynamically links is ridiculous, especially if one believes his claims that GPL isn't any more restrictive than plain old copyright.
Re:Discovering GPL violations (Score:2)
Ah yes, you can't face the truth, so you stoop to personal attacks. Perhaps you are the one who should try openeing your mind. And I'd be very interested if you can show me where in copyright law it states that dynamically linking constitutes a violation of copyright.
Simply put, the company isn't meeting it's obligations if it doesn't make it's best effort to prevent this sort of thing. They accepted those obligations when they assumed ownership (not copyright) of their copy of the library's code.
The company in the hypothetical story didn't copy the GPLed library, so how are they bound by copyright? Answer: they aren't. Yet RMS claims that any non GPLed code that dynamically links with GPLed code is a violation of the GPL. How can one violate a license they never accepted?
Perhaps you should read the GPL again. In section 5 it says: "You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works." The hypothetical company did not accept the license, so they're not allowed to "modify or distribute the Program [the library, in this case] or its derivative works". Well, they didn't modify or distribute the GPLed library, and their program isn't a derived work, since it was written before the GPLed version of the library existed.
I really don't understand why you're picking on the GPL with this scenario. I expect that LGPL'd libraries infrequently switch to GPL.
RMS has been pushing for LGPL libraries to be converted to GPL ever since he renamed LGPL the "lesser" GPL. People also occasionally convert things from BSD/X11 style licenses into GPL licenses as well. Expecting users of LGPL, BSD and X11 dynamic libraries to somehow prevent people from dropping in a binary compatible GPL library, which may not even exist at the time the software is written, is ridiculous.
Anyway, I don't think there's anything wrong with the GPL itself, except I believe the claim that non-GPLed software cannot dynamically link with GPLed code is completely bogus. If RMS and his flunkies will finally admit that the GPL cannot infect software that merely dynamically links, then I'll agree that it truly is less restrictive than copyright.
Incidently, I use the term "infect" because the GPL is commonly referred to as a "viral" licence because the GPL, like a virus, "infects" things. It wasn't intended to be derogatory, merely descriptive.
Re:Discovering GPL violations (Score:2)
First, unless you accept the GPL, you have NO right under copyright law, except what is given to you by Fair Use Law.
In the hypothetical example, the company didn't copy, distribute or modify the GPLed library. Hence copyright does not apply.
Second, if you dynamically link to a library, you are creating a derived work.
I don't believe this to be the case in general, but especially not in the hypothetical example. Explain how a work could possibly be derived from something that was created later?
Let me repeat the hypothetical example, and spell it out a bit more clearly. Imagine the following events were to happen in the following chronological order:
Your statement would be like saying: Well, I confined the GPL'ed code to a seperate function in my program, so that the rest of my code doesn't have to be GPL'ed.
No, that's completely different. In that situation you'd have to copy the GPLed code in order to distribute your program. You're not allowed to do that unless you accept the GPL. The same goes for static linking. My point is that one only needs to accept the GPL if one is going to copy some or all of the GPLed code. Hence code that dynamically links with GPLed code does not itself need to be GPLed. The same goes for RPC calls to GPLed servers, calls to system() on a GPLed command line tools, etc.
Re:Bummer. (Score:2)
Re:Discovering GPL violations (Score:4)
Consider this scenario:
Distro "A" includes shared LGPL lib "B". Company "C" releases closed-source binary "D" that dynamically links against "B".
But, wait! Distro "A"'s *latest* version uses a new version of "B" that is binary-compatible with the previous version, yet is released under the GPL.
What is company "C" to do? All of a sudden they are distributing software that *could* be in violation of the GPL. (Yes, they could statically link that lib or do version checking. But is it really their responsibility to do so? What do they do about the copies already out there?)
GIF images? (Score:3)
cheers,
--sam
--sam
Re:Can we learn a lesson from the Adobe debacle? (Score:2)
The opportunistic lawyers in the Adobe case were using a quirk of German law that doesn't exist in the US. Of course, the US has class action lawsuits which can sometimes be used in similar ways, but not in cases like this.
For a GPL violation, only the copyright holder has standing to sue.
Re:This is an excellent ending to the conflict... (Score:2)
But this is completely wrong: in the vast majority of cases where someone feels wronged and threatens legal action, the case is settled (just as it was in this case), which means that the two parties reached an acceptable compromise or one side backed down (and yes, there's too much of the latter in cases where one party has far more resources than the other party).
Cases that actually go to court are the exception: cases where a compromise could not be reached.
Re:Who wrote the GPL? (Score:2)
Richard Stallman wrote the GPL, with assistance from attorneys, including, I believe, Eben Moglen.
Re:What? (Score:2)
Suits over behavior which has stopped are rare and difficult to pursue- "Yeah, your honor, he stopped doing it, but I want to sue him anyway." This sort of thing is most likely to happen if you're suing for monetary damages, but I get the impression that no monetary harm was done, so this would be difficult. The fact that as yet there is no legal precedent for GPL cases would make such a suit doubly shaky- the first test case really ought to be on a clear-cut and unbending violator, not someone who has already (effectively) admitted defeat.
Re:This result sets a vary bad prescident (Score:2)
If your code does not perform a significant function, it is quite unlikely that it will compete well with the free GPL software that it "wraps".
On the other hand, if you want to turn a GPL program into a photoshop plugin with a couple of wrapper functions, go for it! That's a legitimate use of the GPL -- to make a new facility using shared free code, even if it's for use with non-free code. Because eventually, someone will plug your photoshop plugin into the GIMP....
Keep it Legal! (Score:4)
For immediate release.
Due to the ever increasing potential for GPL code violations, the Open Source community has formed an alliance with your best interests in mind. Details below:
Keep it Legal --it is fast and easy!
Businesses copy code every day. Many of them get caught, don't let this happen to you!
Remember, all it takes is one disgruntled employee to trigger an audit.
Keep your code legal, release early and often! If in doubt about the legal issues surrounding your code just follow these three easy steps to make sure all your code is in compliance with the GPL.
1. Download a copy of our code inspector software. Its powerful search capability will find suspect code quickly and easily. Just point and click your potential problems away.
2. Contact the FSA for a free no risk consultation. Get help with your licensing problems from the people who know licenses best, the FSA.
3. Release any code through our dedicated portal and licensing service. Fast, painless and legal.
Do it today, before it is too late.
Re:Wrong, Learn Your History (Score:5)
and groups for initial mistakes with the GPL so long as they choose to become compliant. The latest one
was KDE/Qt debacle. The FSF seems to use its
leniency as a bargaining chip to bring people into
GPL compliance. IMHO, not a bad tactic.
That said, I am not seeing any indication of FSF
position in this case wrt past violations. They
may yet go to court, though I'd guess they have
better use for their money. OTOH, that press release
had "Open Source" all over it, so maybe RMS will
be pissed enough...
Ouch! (Score:4)
Vidomi has splited their program into two programs
I assume they splited off the part that included the spell and grammar checker.
---------------------------------------------
Re:Discovering GPL violations (Score:2)
#include
No, GPL does not give recipients ownership of the code. If that were the case, there would be no such thing as GPL violations.
GPL leverages copyright to keep the software free (speech, not beer). The original author of the code retains ALL rights, including the right to copy, distribute or make derivative works.
Where the GPL comes in is that the author is licensing to you the rights of copying, distribution and making of derivative works, WITH CERTAIN CONDITIONS. The conditions are of course that you can copy and distribute and even modify the software, but only so long as you make the source code available and all copies and all derivative works must be licensed under the GPL as well. Never are you given ownership of the code, except that when you make a derivative work, you own the modifications and the original author owns the original code.
Re:So did they discover a loophole in GPL? (Score:2)
No. This would go against everything that Free Software stands for. The only way to implement it is to restrict/prohibit/regulate the use of the software. If the FSF does this and calls it freedom, I might as well throw away my dictionary.
Do not restrict runtime linkage and call it freedom. This is absurd. Of course it's a loophole. That's why it's free. If you didn't want any loopholes stick with proprietary software!
Re:is this a problem with the GPL? (Score:2)
The GPL does not regulate the *development* of programs. To quote: "Activities other than copying, distribution and modification are not covered by this License."
The typical header file contains only an interface to the library, and there is already case law that you cannot copyright an interface. A binary that was created using a header file does not distribute that header file.
One possible complication is with header files that actually include code (like inlines, templates, etc). This is problematic, but is still a corner case. For many of these fair use is applicable, but for a few, the terms of the GPL apply.
Re:So did they discover a loophole in GPL? (Score:2)
If GPLd software were indeed contained *within* the closed-source software, then the GPL applies. But in the case of dynamic and runtime linkage, this is not the case. The library is not a part of the application, nor contained within it. They may reside in the same process space, but it is the end user who causes that to happen, and the GPL allows complete and total permission to run the program for any purpose.
Dependency is not derivation.
Re:is this a problem with the GPL? (Score:2)
When I create a binary that is intended to dynamically link to a GPL library, and distribute that binary, I am not distributing or modifying the GPL library. No part of the GPL source is included in my application, either verbatim or translated by a compiler. (a few exceptions exist, which I noted previously)
I've already teared aprt your arument in another psot
Wow! I didn't now that I had an arument that had an aprt teared in by a psot!
Re:is this a problem with the GPL? (Score:2)
The alteration of RAM is performed by the end user in the privacy of his or her own home. The GPL does not apply, and specifically says so ("The act of running the Program is not restricted"). I, myself, have not distributed, modified or publicly copied any GPL covered software.
And please look up the definition of "modify". Being unable to distinguish the boundaries of the library in RAM does not constitute modification.
Re:is this a problem with the GPL? (Score:3)
Re:is this a problem with the GPL? (Score:3)
Wrong. Usage of GPL'd works is completely unrestricted. It only restricts copying, distributing and modifying the work. To quote from the GPL: "Activities other than copying, distribution and modification are not covered by this License."
The license says "if it is linked in thus-and-such a way, you must do these things."
To quote the GPL again: "a "work based on the Program" means either the Program or any derivative work under copyright law."
The GPL is operating under copyright law. It cannot change copyright law, and copyright law is completely silent on the topic of linking. The GPL does not apply to linkage unless it can be demonstrated that the linking process copies, distributes or modifies the Program. It does none of these. (actually a copy is created during program execution by the end user, but the copyright law and the GPL already allow that).
This is no different than a MS license saying "you may not publish benchmarks of this software without consent."
The GPL does not take away any rights already granted by copyright law, and clarifies this point in section 5. The Microsoft EULA, on the other hand, takes away rights that the law has already given to the user. You already have the legal right (in the US) to publish benchmarks about Microsoft products. If you agree and assent to the MS EULA contract, however, you have agreed to waive that right.
Some clarification. (Score:2)
If those who received the 'gpl-violating' code were not given it under the terms of the GPL, then they have no reason to expect source, or anything else guaranteed by the GPL.
That is a *totally seperate issue* from the fact that the company was using GPL'd code in it's products and failing to distribute it under an appropriate licensing scheme; that's up to the authors of the code in question to deal with.
Just because someone used GPL'd code, didn't license it properly, and released a binary does NOT mean that everyone should get their source; it just means they violated the license under which they were given the GPL'd code in the first.
Re:So did they discover a loophole in GPL? (Score:2)
On some architectures, that line can get blurry, but under Windows and Linux it's pretty clear.
It's the difference between calling a function in a DLL or
This is NOT a loophole that you would want to close. Suppoose you did, and you created an operating system and libraries that used your "improved" license. No one would even be able to RUN closed source software on it, because running a program under Unix involves _exactly_ the same mechanisms that you would have "closed". So say goodbye to Oracle or Quake 3 or Wordperfect or ViaVoice
The GPL strikes a very, very fine balance between the rights of users to have control over their software, and the ability of programmers to write closed source software and still run it on an open system.
It is true that things can become blurry. On some "message-passing" style operating systems, there's less of a distinction between a function call and interprocess communication. Luckily, that's not really an issue for any popular OS right now.
Torrey Hoffman (Azog)
Re:Discovering GPL violations (Score:3)
what i would worry about, however, are the many small software/hardware companies who are illegally abusing, and profiting from GPL'ed code. there's no way of knowing if they're in the wrong. additionally, they have the protection of anonymity.
personally, i don't give a damn. while the GPL has its place, too many people are slapping the GPL on their projects simply because its fashionable. i release any of my personal projects under no license whatsoever, so if some poor schmuck really wants to use my code for his employer's closed source project, he can. maybe it will let him come home an hour earlier to spend time with his kids, watch tv, smoke crack, or whatever. seriously, who cares? in a truly Free world, no one should be forced to collaborate.
Re:Discovering GPL violations (Score:2)
Your posts on this subject really highlight how obsolete our intellectual property laws have become. For instance, in the old days, things that could be copyrighted and things that could be patented were obviously different. But computer code seems to lie in a gray area. On the face of it, code seems to be speech, and should therefore be copyrighted. But if you think about it, code also functions like a machine. Fundamentally, programs execute almost like virtual clockwork, and therefore should be patented. So which is it? No one seems to know. Maybe we need a new category, or maybe we should radically reform the whole notion of IP. I think most /.ers would prefer the latter. ;^)
I think it is clear though, that if our policy makers keep applying band-aids like the DMCA that only make the situation worse, then all IP laws will begin to lose power when almost everyone regularly violates them. I remember, about ten years ago, seeing a guy on TV (I believe he was from a think tank or something) talking about how intellectual property would be one of the most important issues our society would have to deal with in the 21st century. At the time, I thought he was crazy. I just couldn't see how ideas, and the ways they are regulated, are all that important. Man, that seems naive now.
--------------------------
"Any fool can make a rule, and any fool will mind it."
Re:Discovering GPL violations (Score:3)
This is true, but practically speaking, patents work almost the same way. We see it all the time; someone gets handed a ridiculous patent because the USPTO does no research on prior art. The patent can later be overturned in court. Likewise, a copyright can be invalidated in court, if, for instance, the copyright holder turns out to have copied someone else's work.
In the example discussed above, let's assume that the USB specifications are so detailed that there is only one way to implement it. I would say that the code is therefore not an original work, as it is really just copied from the spec. Therefore, such a copyright could justifiably be overturned in court. Bear in mind though that IANAL, so I don't know how such proceedings would actually work. I'm just speaking hypothetically.
--------------------------
"Any fool can make a rule, and any fool will mind it."
Re:Discovering GPL violations (Score:4)
This brings up an even larger issue: if there is something that can only be accomplished one way, and people are likely to find the solution independently, should such a thing even be copyrightable (if that's a word)?
It seems to me that the purpose of copyright is to prevent freeloaders from ruining a system. I guess I'm thinking along these lines because I've been using the gnutella network lately and there is a lot of discussion on how to keep freeloaders from ruining that system, but I digress... :-)
When looked at this way, the GPL and proprietary licenses both use copyrights to keep their respective developement systems working properly. Companies like MS charge money so they can pay their employees and shareholders, while GPL'ed projects force code users to release the code for changes or additions. Both, in their own ways, allow for the continued development of the software, while avoiding a "Tragedy of the Commons" type of situation by making freeloading difficult.
However, I think it is clear that in a situation like you have described, there is no freeloading involved, so a copyright should not apply. I'm not sure how copyright law actually works, though, so this is just speculation. I seem to remember that patents are only supposed to be granted for works that are not obvious to an expert in the field (not like this matters in practice). Perhaps copyrights work the same. Do any lawyers out there have more info?
--------------------------
"Any fool can make a rule, and any fool will mind it."
Re:Discovering GPL violations (Score:2)
Of course! That's what the discovery process is all about. http://www.nolo.com/encyclopedia/articles/cm/cm11
Who wrote the GPL? (Score:2)
So, who deserves the credit for the GPL? Is it Richard Stallman himself?
--
Bummer. (Score:3)
Okay, while I'm glad on general principles that there's that much more money not going into the pockets of lawyers, I was looking forward to seeing whether the GPL would actually survive a legalistic grilling from a judge.
Since it hasn't been tested, threatening GPL violations is still sorta at the bluff stage, or so it seems to me. There's still no precedent.
Re:Discovering GPL violations (Score:2)
I disagree with you here. the developer does put the GPLed code in the program that he's writing, but the choice of license is the companies choice. since the GPL allows inclusion of code, the developer did nothing wrong. The company bringing the program out as a closed source app IS infringing on copyright.
//rdj
This was a legal test and the GPL prevailed (Score:3)
No, the judge didn't rule since they settled out of court, but the solution - "fix it so it complies" - is undoubtably what the judge would've ordered if the FSF had pushed to the end and insisted on a full trial.
What do you imagine the FSF's goal to be in such a case? It appears that their notion of their goal is to force companies to comply with the license.
They've succeeded in this case.
Re:Discovering GPL violations (Score:2)
I guess part of my assumption, and I do admit its a big one, is that unethical violations are less significant than intentional violations. Of course, this also assumes everyone has the same measuring stick for valuing loss due to violations
And thanks from the other guy above
Re:Discovering GPL violations (Score:2)
I havn't read the full GPL in some time, but I believe the key issue is in how the binary is distributed. If it is distributed with a LGPLd lib, they are not violating the GPL. If the distro then goes and switches things around, I'd imagine they would be the ones violating the GPL, and could be held liable for damages to the GPL'd lib they substituted in. It really is up to the distro'er to adhere to the licences attached to the software they plan on redistributing.
All that said, this relies on me assuming that dynamically linked libs DO fall under the umbrella of GPL? It doesn't seem like an unfair proposition, but maybe that's not true?
Re:Discovering GPL violations (Score:4)
Okay, so once you can really define what is 'stolen' code, I'd imagine that it shouldn't be too hard to:
- check the symbols in the binary to see if there are any symbols that match up against the GPL'd lib in question
- check what the binaries are dynamically linking against (although I doubt you'd be so lazy as to link against a GPL library dynamically and not expect to be caught)
- check the strings in the binary to see if they contain any strings known in the GPL'd code in question
Of course, this assumes you already have a suspicion that a binary might be violating the GPL of software 'X'.
I almost wonder if it shouldn't be a convention to include some sort of static char buffer 'watermark' in GPL'd libs/APIs, so you could search a suspect binary. Granted, the stealer could recompile the GPL'd libs without the string, or just steal code verbatim, but like I said, its impossible to get 100% certainty.
You know what tho
Just a few thoughts
Re:Discovering GPL violations (Score:2)
A long term approach could be to insure strings get into the code that do mention the GPL and copyright. For a C/C++ file, this could mean including a header file with the GPL & copyright in a string--provided that the string ends up in the executable. Then you run strings and magically the GPL and copy appear. This of course is not a perfect, but there sn't a perfect way to do this.
Re:Discovering GPL violations (Score:2)
Yep. The company has three options; A patched version that does version checking, a static version against the old lib, or ask for permission from "B"'s author to continue using it under the LGPL.
What do they do about the copies already out there?
Welp, they're now potentially in violation of the license. You'd better give them all the newer version of the software that doesn't potentially infringe. (Or in the case of a special license exemption, do nothing at all.)
Before you start poo-poohing the GPL, this happens in commercial software and development tools frequently.
Re:Yes it is (Score:2)
No, it's the consequence of using GPL'd code. MS has the resources to ensure that this doesn't happen. It's really simple - if you don't use GPL'd source code, you are not subject to the GPL. So if you don't want to open your source, don't use GPL'd code. Did I mention that it's really simple? They may PRETEND not to understand that, but they do.
--
Re:is this a problem with the GPL? (Score:4)
Since it isn't actually linked with the GPL'd code but rather uses bog-standard IPC, then there really isn't anything that can be done, unless someone wants to try and make the GPL applicable to anything that a GPL'd program talks to, which I'm pretty sure would never fly.
Two words: (Score:4)
disgruntled employees
A large number of software copyright violations are not found by audits, but by ex-employees. This won't get every company that does this, but it can get a surprising amount.
The unethical developer woould put it in on purpose in case they were let go under poor terms.
What about the other infringed projects? (Score:5)
Either way the VirtuaDub author seems just as pissed as most of the Slashdotter here about how they nver released the original source.
--
Wrong, Learn Your History (Score:5)
Wrong. The point of the GPL is that users of software have complete and total freedom with the software they've been given not the next version or the one after but the version that was distributed to them.
I don't see why using it as a lever to get a company to release proprietary source code they never intended to open would do any good.
If the proprietary code is made up of seven different Free Software components [virtualdub.org] then the users of the software are supposed to get the source for the software.
--
Re:This is not good! (Score:3)
Imagine if everyone went around prosecuting everyone without giving them a chance to right their wrongs. That's certainly not how I'd want things to work.
The only "intuitive" interface is the nipple. After that, it's all learned.
Yes it is (Score:3)
I don't see why using it as a lever to get a company to release proprietary source code they never intended to open would do any good. That would give Microsoft plenty of fuel for their "viral GPL" argument -- "See, if you even touch this stuff you'll be forced to release the source code for your ENTIRE PRODUCT LINE!"
Sure, Vidomi screwed up. But the gracious settlement ("Just fix it and we're cool") seems a lot better for all concerned.
Re:This is not good! (Score:5)
This is not good! (Score:3)
Re:"Free Software"... (Score:3)
How many companies must Stallman destroy before he forgets about Symbolics.
Let's find out. A-One... A-two... A-threeee... CRUNCH! Three.
Re:enough already (Score:2)
I think that it's a good think that posts are not edited before posting (except occasionally for brevity).
Umm, good point, except look again... They did fix it. They may not be edited before posting, but they sure are edited after posting.
Re:Discovering GPL violations (Score:2)
IANACRL (IANA Copyright L) but I think that this is misconstrues current copyright law. Copyright applies to a work and derived works, not to works that happen to be similar incidentally. IOW it would be a valid copyright defense to show that you came up with your idea independently even if it did look very similar to somebody else's implimentation. You could probably do with good record keeping. CVS entries, memos about design discussions, etc. could be used as evidence that your solution came from your own decision to approach the problem in a particular way and not from copying the other guys' code. It would eventually be up to a jury to decide wether the evidence favored you, and my gut feeling is that if you actually did come up with the idea independently and had documentary evidence to prove it that you could convince a jury.
Re:presrvng trd secrts while Discovering GPL violt (Score:2)
The courts would actually use something much simpler than this. They would appoint a "Special Master" (I think that's the right term) who is basically someone who the court thinks is both knowledgable enough to tell if the code may have been swiped and honest enough not to blab any trade secrets. He is then given access to both codebases and looks them over to see if there's any evidence of wrongdoing. If he thinks that there's enough evidence to go forward, then the lawyers are allowed to subpoena the code and let their experts go over it with a fine toothed comb to find obviously snagged chunks of code. The code would probably remain under seal, though, which means that there would be very harsh penalties for letting anything slip (at least until after a determination that the code had been lifted and must be made available). If the final decision is that copyright violation has not taken place, anyone who did leak the trade secrets would be in deep trouble.
Re:This is an excellent ending to the conflict... (Score:2)
thats not what itds really for. It's supposed to be the way to get to a final point when all other options have been exhausted
Your disappointment should lie with people and corporation that see the courts as the ONLY way to solve something, instead of looking for other solutions first.
I know this is off topic, but I think people really need to make an effort to understand the US judicial systems history, or at least an overview. Much to my surprise, in the context of history, much of it actually does make sense.
Re:Discovering GPL violations (Score:2)
Strictly speaking, the GPL cannot prevent you from distributing anything that you have written yourself, since you are responsible as the copyright holder for enforcing the license. However, you would need to add a special exception to the license giving others permission to link it against the MFC, or else nobody else would be allowed to distribute it.
Take a look at Galeon's license for an example of this. The Gecko library is under MPL, so they have to give special permission to link to it.
Explanation from the FSF's GPL FAQ. [fsf.org]
The real lesson (Score:4)
Re:Nope. (Score:2)
The big deal is that you do not own the code and you don't have the right to do anything with it that's prohibited by the license; Such as using it in your own program (unless you then release that program under the GPL).
Code is intellectual property. Please do not confuse this with real property.
Re:Ouch! (Score:2)
********************
Maybe someone can help explain something to me... (Score:3)
Company takes GPL'ed code and puts it into their product and sells said product.
People notice their use of GPL'ed code and alert the FSF.
Company then (for its next release) makes it into 2 products instead of releasing the source code of the product that is already out.
Whats to stop any other company from making a "Woops! We didnt know that... here, next release we will split it into 2 different programs, k?"
Really, now, people (Score:5)
This news makes me so happy, I shited my pants. The original GPL violation made me so agry I spited.
Re:So did they discover a loophole in GPL? (Score:2)
GPL is designed to prohibit the use of GPLed software in close-source non-free (in GPL's sense of the world 'free') programs, IMHO. If you can get away with doing that via some IPC/RPC tricks, it is a loophole and probably needs to be taken care of to remain consistent with that policy.
So did they discover a loophole in GPL? (Score:3)
So then if what they did is legal than the same can be done with any other GPL application. Simply write an open-source stub that would link with the GPLed code and then use IPC/RPC/etc to communicate with the main program that you don't want to open-source. It will certainly be much slower than direct linking, but if speed is not an issue then it will work just fine. It seems to me that if GPL does indeed allow this than it is a definite loophole that perhaps needs to be fixed in a new version of the license.
Re:This is not good! (Score:3)
But it was accepted, by the FSF's lawyer (Eben Moglen [columbia.edu]). Since FSF is one of the few organizations with the power and resources to sue on behalf of the GPL, and many GPL'd works are copyrighted by the FSF (as recomended), then this is an acceptable solution.
If it went to court, it may have been neccessary to release the source for the original, or the judge could have decided this was the proper solution.
Although I'd love to live in a world where GPL worked like a open-source virus, the truth is we live within a legal system where outcomes like this are totally acceptable. Personally, I think it's a win for the GPL, and it shows one test case of using GPL software in a commercial environment - in a non-virial way.
Software patent! (Score:2)
The difference should be the expiration time. Software is good for only a few years before it loses most of its marketable value. I think the IRS says the depreciation time is 3 years for computers and software. So, just to be generous, why not make it good for 5-10 years? Regular patents are good for 20 years and copyright is good for 120(?) years. Developement of software is obviously much faster. If a shorter timer were allotted, it would ACTUALLY drive INNOVATION forward, in the real sense of the word. Companies would have to keep _really_ inovating to stay in business. Since software is so easy to reproduce, they should only be able to have a reasonable amount of time to recoup their R&D costs + some proffit.
is this a problem with the GPL? (Score:4)
Of course, as many have pointed out, this is a fallacy - a DLL is, after all, another form of library - even if the code is not statically linked, it's linked nonetheless. The LGPL is designed as a less restrictive form of the GPL specifically for this purpose - enabling the distribution of a library without the "release your source" requirements of the GPL. Since Avery did not use the LGPL, we can assume that he intended the full requirements of the GPL to apply. In this case, fortunately, Vidomi has conceded.
Unfortunately, I can see future confusion arising the same question - what constitutes linkage? It's fairly trivial, for example, to write a small standalone application that links directly with a GPL library/DLL, and listens on a local TCP port. On receiving encoded commands from the TCP, it translates these to function calls into the GPL code, and returns the results back over the TCP connection - RPC style. Can the offending company, having written a trivial RPC layer, then release the source code for the server program, while keeping the client code closed-source?
Although the client is making extensive use of GPL code, it's not linked with it... it's in a completely different process. In fact, it could be on a completely different machine.
This strikes me as a relatively easy way for companies to get around the requirements of the GPL. Anyone have any thoughts on this?
Strags
I figured... (Score:2)
...that someone would make this argument at some point. I understand it, and in some ways, I'd like to see the GPL [as well as other free/open licenses] tested in a court of law, mainly for the attention that would bring to the licenses.
But, however, the fact that Vidomi realized they screwed up and weren't going to get away with it and fixed the violation says to me, "We knew we would lose." The GPL hasn't been invalidated, and no lawyers are signficantly richer to prove that fact. Shouldn't we be happy for that? =)
Re:This is not good! (Score:3)
In a regular copyright violation case, the violators are liable for economic damages caused by their infrigement and have to pay up. There obviously aren't any economic damages in the case of Free software. So what are those damages? I would argue that they are the fact that improvements don't get shared with the community. The "price" charged by GPL software is that improvements must also be GPL. So, the damages arise from the fact that they're not. Hence, reparations would seem to be releasing the code -- all of it. After all, in regular copyright violations, the violator is liable for *all* lost revenue, even if they spent some of it on printing or whatever. Usually more, in fact, as apunitive damages. Hmm -- writing more code as punitive damages? what do you think? However, despite all this, I think the correct approach for the community is to generally be nice about things, violations included.
The FSF has approved nothing (Score:2)
Please read the letter!
---
Re:Discovering GPL violations (Score:3)
Plus this gets us into the nasty scenario of there being only one way to perform a task (or onr OPTIMAL way), and then having the code for that task (or the optimal method for said task) being GPL'd.
Example: USB code in the kernel for Linux. Someone at some embedded development company needs to make their device USB compatible, so they write their own code to work with USB-- they've never used Linux, they've never seen the source for the kernel, but the compiled binary (let's say they both run on an x86 architecture) are almost exactly the same.
Would we immediatly assume the worst as a community, ignoring the possibility that the company and/or developers wrote their own code to handle USB? Or would we assume the worst because some developer, not even on the same team as the embedded developers, ran Linux at home and was on the kernel mailing list?
I guess I'm afraid that at some point we'll start witch-hunts for people who use GPL code and demand they open the entire project. I do want the GPL enforced, but certain things are so common that they're bound to be copied (by copied, I mean duplicated through the same efforts and work as the other party) over time.
Re:presrvng trd secrts while Discovering GPL violt (Score:2)
~
So would THIS be a violation of the GPL ? (Score:2)
What about if you are distributing some commercial software, which runs on Linux ? Could you distribute Linux and your software at the same time, while keeping your software free of the GPL and without violating the GPL ? Here again you could argue that your software is a distinct entity from the GPL'ed Linux, but someone else could turn around and say that it depends on Linux (as it runs on it), and as such Linux constitutes a part of the program. Maybe you could get around this by distributing Linux separately from your program, but if this latter view is valid, would it even work anyways ?
This result sets a vary bad prescident (Score:2)
The Vidomi result seems fair (and was accepted by the FSF) but how small a piece of code can constitue an application for purposes of release under the GPL? Can I take GPL'd code and write a couple wrapper functions and release that piece of code and call it a plugin to my main application which would not be released under the GPL? Does the part of my code distributed under the GPL actually have to be useful or can it simply be a set of wrappers?
Conversely, if I can't release only a GPL'd plugin to my main closed source application, can I a s a developer use GPL'd code inside a plugin I write for a 3rd party commercial application such as Photoshop?
The Vidomi resolution raises a great many questions along these lines - certainly more issues than it resolves...
--CTH
--
What this means to MSFT (Score:4)
All any developer need do, to use Open Source software, is invoke it as a separate program from the commercial program. All a company need do is keep all the stuff not part of its main line of business (the "crown jewels") in a commercial separate program and keep as GPL all the stuff that it doesn't need to control.
As an example, let's say the City of Seattle was reselling a computer program for electricity bill subrogation (a real example). They could have the really nifty stuff in a commercial program and leave most of it as GPL. The advantage is it's easier to resell - anyone who wants to can custom-code most of it, so long as it's not in the commercial section, which helps sell it, while letting the seller keep control of the proprietary code they sweated blood and research time to develop. Coders at the buyer are happy, cause they can fix bugs more often, and the seller is happy, cause more people buy their software.
End result is: GPL means more market!
Re:splited? (Score:2)
Re:Discovering GPL violations (Score:2)
In cases like this, it's pretty easy to find out a violation took place. But what about a major closed-source project that uses pieces of GPL-d code? What if an embedded OS developer decided to use some Linux kernel code, without attribution, in a proprietary system? Would it be possible to detect the violation (looking for patterns in the binary, for example)?
Hmm... and even if you find the strings in the binary which suggests that GPLed code was used illegally, there's a quick and easy way out of it. The company just has to use some chickenshit encryptuion on the binary. The person who finds the strings will have violated the DMCA in order to be able to bring up the issue of GPL vilation in the first place. Then the FBI can arrest that person, and throw him in jail without bail.
And we all now know that this isn't a paranoid delusion scenario.
-Rob
Morality is just confusing the issue (Score:2)
If you were doing it responsibly, IE, leaving a mix of old and new growth standing and truly planting as much as you were cutting down, then yes, it would be okay.
Even though I was driving 25 mph over the limit, it's okay, because I slowed down before I got home?
If you realized you were driving 25 mph over the limit and decided to slow down rather than get a ticket, then yes, you've done the right thing. You may still get pulled over by an overzealous cop, but you can probably successfully argue the ticket in court.
The point here is that the company that makes Vidomi was forced to realize and admit that they were doing the wrong thing.
Sure they *were* doing the wrong thing, but they corrected their actions in a manner that brought them into compliance with Avery's and the FSF's interperetation of the GPL.
Remember that Avery and FSF could still have pushed the case into court if they wanted to. Obviously they thought that they were better served getting the other guys into compliance than spending big $$$ on court costs.
Rainforest (Score:2)
Now, if the regions were picked selectively... say you harvested a fifteen-square mile area in a striped or checkerboard pattern, and then left the uncut trees to stand while replanting what you just cut down, you minimize a lot of the damage deforestation would cause. Unfortuneately, this is *not* happening.
Discovering GPL violations (Score:5)
In cases like this, it's pretty easy to find out a violation took place. But what about a major closed-source project that uses pieces of GPL-d code? What if an embedded OS developer decided to use some Linux kernel code, without attribution, in a proprietary system? Would it be possible to detect the violation (looking for patterns in the binary, for example)?
Would it be possible to compel the company to show its source to a court in the event of a lawsuit?
The GPL may be enforceable, but that is cold comfort unless it is possible to detect and combat the use of stolen code.
Re:statutory damages: lost revenue not needed (Score:2)
However, I would have held out for a symbolic $1 damage payment also, just to establish that Vidomi recognized that they had infringed copyright. (It's not a bad deal for Vidomi either: if they settle and the copyright holders accept a nominal payment, then no one can change their mind and decide to sue later.)
Re:Discovering GPL violations (Score:2)
In such a case, a patent would be more appropriate. In cases of independent inventions of the same thing, patent law gives full rights to the first inventer (in the US) or filer (in the rest of the world). Copyright law just assumes that no two people are ever going to independently make up the same story and tell it the same way, and doesn't define any way to resolve the issue if that's what really happened.
Re:What? (Score:2)
On the other hand, if Vidoma really wants to be sure it's over, they should offer each of the authors something (say $1,000) as a settlement in full -- otherwise it would indeed be possible for one of them (if he's rich enough) to sue for those damages. The likely result of this is that each set of lawyers gets $500K, leaving the plaintiff -400K, Vidoma -600K, lawyers +1M, but there are people pigheaded enough to be happy with that!
Re:What? (Score:2)
Sounds a little harsh, but AFAIK the law lets them do it. (IANAL) If you want to complain about it, write your congressman. If he still reads anything that isn't accompanied by $$$$...
What? (Score:4)
Re:is this a problem with the GPL? (Score:2)
Perhaps. But what about a program developed using GPL header files allowing access to a GPL library?
Re:This result sets a vary bad prescident (Score:2)
I always had some suspicion... (Score:3)
Let's sum it up:
a) It hasn't been tested in court.
b) You would have a tough time proving that it is actually stolen code. (Companies releasing closed source code? I don't think so.)
c) There are ways to get around it, ie to split the binaries and just show the links to libraries.
Oh... a sad day.
Screw 3...
Re:Maybe someone can help explain something to me. (Score:4)
To behave ethically you must always alert the wrongdoing part and then let them correct it anyway they want to.
Then if you have been harmed economically while the wrongdoing was taking place you can ask to be compensated for this. In this case the code was free so it's not the case here.
Take patents as an example. If someone is breaking your patent you must always let them fix that. You can't just sue the ass of them.
That is not morally defendable, maybe they did it by mistake or some other circumstances we don't know about.
Atlest this is the case in all western countries witch has similuar laws.
Re:This is not good! (Score:3)
Re:enough already (Score:2)
I think that it's a good think that posts are not edited before posting (except occasionally for brevity). I suppose the one thing they could do is do all of the editing of the submissions and put a little "[sic]" where the poster made a misspelling.
But this is not the New York Times, and it is not supposed to be, you're reading Slashdot. A collection of links submitted by readers. They usually do a good job of editing the features they write, and that's enough for me. I'm fed up with the focus on the occasional misspelling.
OSDN: home of illiterates.
If by "illiterates" you mean people who occasionally make spellings or grammatical errors, then you are describing much of the readership of /. (myself included). So maybe you are right... this is a decent home.
This is an excellent ending to the conflict... (Score:4)
One of the biggest dissapointments I have in the US judicial system, is that it does not generally foster an attitude of compromise.
I think it is great that Vidomi and the FSF were able to work together to find a middle ground that fits the definition of the GPL
One of the best ways of complying with a license, is doing just that... finding ways to comply. Perhaps not a viscerally satisfying ending, but certainly one that is in the spirit of the open source community. If only all the GPL issues could be resolved with as little intervention of the legal establishment.
In a similar vien, make sure you write to the people at linuxda.com, and make them politely aware that what they are currently doing does not conform to the behavior expected by the open source community.