Slashdot is powered by your submissions, so send in your scoop

 



Forgot your password?
typodupeerror
Check out the new SourceForge HTML5 internet speed test! No Flash necessary and runs on all devices. ×
GNU is Not Unix

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.
This discussion has been archived. No new comments can be posted.

Vidomi GPL Violation Case Resolved

Comments Filter:
  • by Anonymous Coward
    Me fail English? That's unpossible!
  • by Anonymous Coward
    I'd hate to see the arguements here on Slashdot if Microsoft was caught using GPLd code. The problem with the first post's interpretation of the GPL is its severity. Imagine if someone at Microsoft placed a non-essential GPLd component into Microsoft Office, such as a jpg convertor. To be forced into releasing the source code for Microsoft Office + Windows (due to integration of now GPLd libraries) due to a minor infraction is completely unfair. The problem lies in what constitues a significant portion of the functionality of a program. Therefore, rereleasing the program to a state where it is no longer using the GPLd source is the only acceptable remedy.
  • by Anonymous Coward

    These comments assume that the people who work on the proprietary source code are unethical. How do you catch a violation?

    • a whistle-blower in the company
    • a disgruntled employee who knows of the violation
    • the company itself admits it once the issue is brought to the attention of management

    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.

  • by Anonymous Coward
    The company I worked for had their closed source code stolen about 5 years ago. The way we finally proved that they stole the code was showing that both their product and our product had the same obscure bug. After showing this to the judge/arbitrator (I can't remember if it was a full blown court case or arbitration) the case was over. They were forced to pay us lots of money to purchase rights to our source code so they could use it in their own product plus damages to us.
  • by Anonymous Coward
    Exactly!!! A company I used to work for violated the GPL by compiling glibc into their programs. When it was pointed out to management their reply was, "So what! There has never been a lawsuit filed for it." (at that time, yes) The company even told the FSF that there was a problem and they were working it out. FSF said, "OK". The company released an "open source" version while continuing to sell the illegal version. This was a major factor in my leaving the company, before it hit the fan. One question I ponder is, what's the difference if the FSF will not stand up for it's own GPL? They did in this instance but didn't in a lot of other cases. Why worry about the GPL if practically no one will get sued. The names were changed to protect the guilty.
  • by Anonymous Coward
    I'm the author of VirtualDub, and I'm posting as AC because I'm too lazy to look up my old login. I never thought I'd be defending Vidomi, but here goes....

    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. :)
  • by Gleef ( 86 ) on Thursday July 19, 2001 @04:47AM (#75790) Homepage
    As long as the program as distributed is compiled and linked against the LGPL version of B, they're fine. If/when they distribute a copy of B to be used with D, they should distribute the LGPL version. The fact that it works with GPL versions of B too is a happy side effect, and there is no guarantee that later versions of B will still work. If later GPL versions of B break binary compaitibility with the LGPL version, they can't upgrade, since they're only allowed to distribute versions linked with the LGPL version.

    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.

    ----
  • I think most of the violations of the GPL are perpetrated by lazy and dishonest programmers within some more-or-less ethical company. For instance, some guy needs a regex parser, but Windows doesn't include any libraries for this (true the last time I asked, quite a while ago). Options:
    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
  • by Paul Komarek ( 794 ) <komarek.paul@gmail.com> on Wednesday July 18, 2001 @09:58PM (#75793) Homepage
    Copyright says that the recipients don't have any ownership of the code at all. GPL says you have ownership, but with some responsibilities. Seems to me that the GPL is less restrictive (you own it and can produce derivative works, etc) than copyright. I think you have the wrong idea about copyright, including the idea of "derivative works".

    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.
  • by Masem ( 1171 ) on Wednesday July 18, 2001 @12:33PM (#75795)
    While this isn't a clear cut win for the GPL, it does at least show that the GPL has some guts, else why would Vidomi settle? If they felt that the GPL was meaningless, then they most likely would have fought this all the way through. So at least two companies (Microsoft and Vidomi) are taking the GPL seriously.

  • Well, if you agree with the GPL, then why should you care who pays for its enforcement - provided that it is enforced?

    --

  • by Sanity ( 1431 ) on Wednesday July 18, 2001 @02:40PM (#75797) Homepage Journal
    So we learned with Adobe that opportunistic lawyers can sue people who infringe on trademarks, take a cut, and give the rest to the company they sued.

    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.

    --

  • But the company hasn't really done anything wrong, have they? They never had to agree to the GPL, because they aren't distributing any GPLed code.

    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.
  • you might consider reading about copyright, and engaging your brain before opening your mouth (or typing =-).

    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.
  • I think you need to read more carefully.

    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:
    • a library libfoo is released under LGPL (or possibly even an X11 or BSD style license)
    • someone else develops a non-GPL program quux that dynamically links with libfoo
    • a GPLed libfoo that's binary compatible with the original libfoo is released
    So the non-GPLed program quux was written before the GPLed libfoo, yet it is possible that a user might install the GPLed libfoo as well as (the non-GPLed) quux. In that situation, quux would dynamically link with the GPLed libfoo, but no reasonable person would claim that quux was derived from the GPLed version of libfoo.

    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.
  • It's important to understand exactly what the GPL is. Have you ever seen the copyright notice on the back of a CD case or in a book? It says something like, "Copying without express written permission of the author is prohibited." Well, the GPL is exactly that "express written permission." It grants exceptions to copyright law under certain conditions. It's a broad waiver of the monopoly right.
  • by mandolin ( 7248 ) on Wednesday July 18, 2001 @01:52PM (#75804)
    - 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)

    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?)

  • by petrov ( 7314 ) on Wednesday July 18, 2001 @12:41PM (#75805) Homepage
    Am I the only one that found it funny/ironic that Vidomi used GIFs for the scanned images of the letter from the FSF? Given Stallman's opinions scattered liberally around prep.ai.mit.org (next to every image), I cracked up.

    cheers,
    --sam
    --sam
  • 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.

  • One of the biggest dissapointments I have in the US judicial system, is that it does not generally foster an attitude of compromise.

    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.

  • Richard Stallman wrote the GPL, with assistance from attorneys, including, I believe, Eben Moglen.

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

  • 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?

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

  • by PotatoHead ( 12771 ) <doug@openg e e k.org> on Wednesday July 18, 2001 @06:37PM (#75814) Homepage Journal
    Press Release from the FSA

    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.

  • by Compuser ( 14899 ) on Wednesday July 18, 2001 @02:38PM (#75816)
    Well, the FSF has a history of forgiving companies
    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...
  • by NMerriam ( 15122 ) <NMerriam@artboy.org> on Wednesday July 18, 2001 @12:07PM (#75817) Homepage

    Vidomi has splited their program into two programs

    I assume they splited off the part that included the spell and grammar checker.

    ---------------------------------------------
  • Copyright says that the recipients don't have any ownership of the code at all. GPL says you have ownership, but with some responsibilities. Seems to me that the GPL is less restrictive (you own it and can produce derivative works, etc) than copyright. I think you have the wrong idea about copyright, including the idea of "derivative works".

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

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

    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!
  • But what about a program developed using GPL header files...

    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.
  • GPL is designed to prohibit the use of GPLed software in close-source non-free (in GPL's sense of the world 'free') programs

    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.
  • If I do not accept/assent to the GPL, then I am not allowed to distribute or modify the program. Copyright law still allows me to use the program for any purpose, to copy the program for my own personal use, to reverse engineer the program, and to publish benchmarks and reviews on the program. (fair use is a slightly different matter).

    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!
  • Although shared/dynamic linking doesn't change the binary on the HDD, It does alter it in RAM, making it impossible to tell apart where the your program ends and the library starts, thus modifying you program.

    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.
  • by Arandir ( 19206 ) on Wednesday July 18, 2001 @03:27PM (#75825) Homepage Journal
    It doesn't matter what the FSF says, or what RMS says, or what the general opinion on Slashdot is. All that matters is what copyright law and the GPL say. A program linked by the end user at run time to a GPL library is NOT a derivative work! If you disagree, please cite copyright law where I am wrong. I've searched and searched and I can't find it.
  • by Arandir ( 19206 ) on Wednesday July 18, 2001 @10:14PM (#75826) Homepage Journal
    All that matters is that they use GPL'ed works.

    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.
  • No. You are confusing the issue.

    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.
  • No, the GPL does not allow _linking_, but linking is NOT the same thing as communicating via some sort of message passing.

    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 .so (linking) and sending messages down a pipe, or using a shared file.

    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 ... or any of the other closed-source apps that are really nice to have on Linux.

    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)
  • while, in theory, your fears do have a basis, in practice, i wouldn't worry about it. most big corporations out there are extremely paranoid about making any kind of internal legal/licensing errors. these are the same people who spend thousands on licensing C compilers and making sure that every single windows installation is 100% legit. they're just as afraid of lawyers and such as any of us (if not moreso). and chances are that their source code is constantly under review, and it is often licensed/sold to other companies and/or universities (even microsoft lets universities and such look at some of their source). for a big company, it is extremely important to make sure your source is legally self-contained, because you never know when you'll be selling it. and what if you inadvertently hired an RMS-like zealot to work on your shady source code? there's just too many risks, so its just not worth it.

    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.
  • 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."
  • by msaavedra ( 29918 ) on Wednesday July 18, 2001 @03:30PM (#75835)

    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."
  • by msaavedra ( 29918 ) on Wednesday July 18, 2001 @01:10PM (#75836)
    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.

    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."
  • "Would it be possible to compel the company to show its source to a court in the event of a lawsuit?"

    Of course! That's what the discovery process is all about. http://www.nolo.com/encyclopedia/articles/cm/cm11. html has a little info about that.
  • We take great pains to give credit to people who write good code, but pound-for-pound, the GPL seems to be doing more good for the Free Software cause than any piece of code.

    So, who deserves the credit for the GPL? Is it Richard Stallman himself?
    --
  • by devphil ( 51341 ) on Wednesday July 18, 2001 @12:13PM (#75842) Homepage


    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.

  • >The truth is that companies do not steal the GPL code, but the software developers do.

    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
  • by dhogaza ( 64507 ) on Wednesday July 18, 2001 @12:33PM (#75847) Homepage
    If the company felt it was going to win, it would've continued the case. This represents a victory by the FSF and the GPL. Remember that the company first refused to comply, went to court, and have now backed down and have agreed to comply. Someone scored a point here, and it wasn't the company that was in violation of the GPL.

    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.
  • This is true. Although for the ethical publisher, the idea of a watermark convention for GPL'd code would help then, wouldn't it? You wouldn't have to know the development details in order to have some sort of standardized check for GPL'd code.

    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 .... I guess I was thinking that it was more worth concentrating on how to detect intentional violators. It would probably be easier to catch them, easier to prosecute, and thus fuel the neccessary awareness to reduce unintentional violations? Just a guess, tho.

    And thanks from the other guy above .. yes, DMCA, not DCMA .. damnit, when it comes to acronyms, I just choose the one that rolls off my tongue the easiest. I hope it doesn't distract from the point of my comment. Thanks!
  • In this case, I'd have to say that the developer is in no way liable, since technically, the copy of the app s/he distributed included a non-GPL'd lib. If the distro then switches up libraries, it is the distro'er who is distributing binaries that violate the GPL, not the developer. If the developer provides LGPL libs with their distrobution, it is the distro'ers responsibility to ensure that that library ships along with it.

    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?
  • by SirSlud ( 67381 ) on Wednesday July 18, 2001 @12:53PM (#75850) Homepage
    Considering the grey-area of what constitutes 'stolen code', I don't think there will ever be a way of being 100% sure. Is taking a clever 2 line 'for' loop from someone elses code (that doesn't contribute greatly to the core functionality of either the GPL or the code-stealer's product) stealing? This has probably been discussed at length at /. before, but I thought it was worth pointing out that nothing is black and white (or whatever colors you've set in your terminal ;).

    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 .. with all the DCMA bruhaha going on, the core issue is trying to catch 100% of all infractions. I'd think it to be slightly hypocritical to suggest that the GPL community should go all out to ensure 100% compliance given the resistance to similar efforts from the content/media industry. I think 10% of technical infractions (and I'll argue that they are the visible, obvious, easy to detect infractions) of both the GPL and DCMA misuse constitutes 90% of the loss for both licences/acts. In the case of media, the loss is revenue and control, in the case of GPL, the benifits of collaberation, credit, and revenue to the original authors of code. In fact, if it can be prooven that not writing up tons of technical barriers and legal restrictions beyond the core purposes of the GPL doesn't damage the community to a large extent, it'd be good fodder to throw back to the backers of the DCMA .. you'd be able to say, 'Chill ... we know there is some misuse, but we're still in business and benifiting off of the existance of the GPL. Same should go for the DCMA.' You know, like J-walking .. its technically illigal but not econmically or socially viable to persure means of ensuring 100% compliance. In other words, the possible loss in value resulting from infractions of the GPL and DCMA are not worth the inconvenience of pursuing 100% compliance.

    Just a few thoughts .. okay, putting on my flame retardant suit now. Interesting question tho .. I've thought about this a few times myself.
  • Use the strings program to find GPL related strings.
    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.
  • What is company "C" to do? All of a sudden they are distributing software that *could* be in violation of the GPL...But is it really their responsibility to do so?

    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.
  • To be forced into releasing the source code for Microsoft Office + Windows (due to integration of now GPLd libraries) due to a minor infraction is completely unfair.

    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.

    --
  • by Chirs ( 87576 ) on Wednesday July 18, 2001 @01:23PM (#75858)
    Actually, this is exactly the main method of "getting around" the GPL. The only drawback is that this involves some increased latency so its not really suitable for high-performance software.

    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.
  • by Fjord ( 99230 ) on Wednesday July 18, 2001 @05:52PM (#75866) Homepage Journal

    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.

  • The original author of VirutuaDub put up a page about Vidomi [virtualdub.org] where he mentioned that SloMedia infringed seven projects (VirtualDub, FlaskMPEG, DVD2AVI, MPEG2DEC, AC3DEC, XingMP3, smart deinterlacer). Does the newly GPLed source cover all the infringing projects or just VirtuaDub.

    Either way the VirtuaDub author seems just as pissed as most of the Slashdotter here about how they nver released the original source.

    --
  • by Carnage4Life ( 106069 ) on Wednesday July 18, 2001 @12:46PM (#75868) Homepage Journal
    The point of the GPL is to ensure that open-source programs remain open-source and freely modifiable.

    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.

    --
  • by Galvatron ( 115029 ) on Wednesday July 18, 2001 @12:26PM (#75874)
    Actually, yes it is. Otherwise, we would be as bad as that German law firm that demanded money even though Killustrator changed its name. If someone fixes the violation, then they should not be held responsible for their earlier violation.

    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.

  • by Emnar ( 116467 ) on Wednesday July 18, 2001 @12:25PM (#75876)
    The point of the GPL is to ensure that open-source programs remain open-source and freely modifiable.

    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.

  • by MrGrendel ( 119863 ) on Wednesday July 18, 2001 @02:40PM (#75877)
    No one can be forced to license their code under the GPL, even if they have violated the license. If a company violates the GPL, either deliberately or by misunderstanding the requirements, it is a copyright violation and should be handled as any other copyright violation. They really have two choices when it comes to resolving this: open up the violating code, or stop distributing it. They chose to take the second option and stop distributing the program in a manner that violates the GPL. Compliance has been enforced.
  • by Jagasian ( 129329 ) on Wednesday July 18, 2001 @12:13PM (#75880)
    So did they ever release the source for the earlier binary that was causing all of the trouble? It would be like Microsoft making MS-Linux, but not releasing source code, and then, in order to settle out of court, they make another different version called MS-Linux XP which has things separated to avoid lincensing issues. The point is that the issues are with a different binary and a different code base! Breaking the GPL and then releasing a different similar binary and source code can't be an accepted way to allow people to break the GPL and get away with it.
  • by istartedi ( 132515 ) on Wednesday July 18, 2001 @04:40PM (#75881) Journal

    How many companies must Stallman destroy before he forgets about Symbolics.

    Let's find out. A-One... A-two... A-threeee... CRUNCH! Three.

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

  • 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)?

    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.

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

  • One of the biggest dissapointments I have in the US judicial system, is that it does not generally foster an attitude of compromise.
    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.
  • From another perspective, suppose you write a program which uses the Microsoft Foundation Classes (MFC). Are you prohibited from releasing that software under the GPL because MFC is not GPL'd?

    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]

  • by The Pim ( 140414 ) on Wednesday July 18, 2001 @01:24PM (#75895)
    I think the important thing to take away from all this is that Professor Moglen writes his legal documents in LaTeX.
  • Keep in mind that you don't legally own any GPL'ed code unless you wrote it yourself. You merely have a license to use that code according to the set of rules and conditions set forth by the license.

    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. :-P
  • It's a part of their strategery to use extra helping verbs and cutback on the dreaded "t" wear and tear that occurs on most keyboards.
    ********************
  • by Lostman ( 172654 ) on Wednesday July 18, 2001 @12:17PM (#75905)
    Lemme get this straight:

    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?"
  • by AaronStJ ( 182845 ) <AaronStJ.gmail@com> on Wednesday July 18, 2001 @12:18PM (#75907) Homepage
    Vidomi has splited their program into two programs

    This news makes me so happy, I shited my pants. The original GPL violation made me so agry I spited.
  • Do not restrict runtime linkage and call it freedom.
    But it already restricts runtime (i.e. dynamic) linkage? What is the difference here?

    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.
  • by DmitriA ( 199545 ) on Wednesday July 18, 2001 @01:05PM (#75911)
    Ok. So they wanted to link with some GPLed code, but of course that was prohibited by the license. So what they did now was create another stub open-source program which links with the GPLed code and then used IPC shared memory mechanisms to pass the information to the actual close-source program that does everything. Am I reading this right?

    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.
  • by JWhitlock ( 201845 ) <John-Whitlock@iee[ ]rg ['e.o' in gap]> on Wednesday July 18, 2001 @12:33PM (#75914)
    Breaking the GPL and then releasing a different similar binary and source code can't be an accepted way to allow people to break the GPL and get away with it.

    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.

  • This is why a new catagory if IP should be created. A software patent should be awarded to an invention that it implemented in software. Extending the idea, this would cover algorithms and mathematical formulas, as well computer programs.

    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.

  • by strags ( 209606 ) on Wednesday July 18, 2001 @01:06PM (#75919)
    Much of the debate between Vidomi and proponents of the GPL has been prolonged by Vidomi's incessant questioning of what exactly consitutes linkage. They have maintained from the very beginning that they don't think they're doing anything wrong, since the GPL code is in a separate DLL.

    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
  • ...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? =)

  • by evanbd ( 210358 ) on Wednesday July 18, 2001 @04:09PM (#75923)
    Just a thought, here; let's see where it goes.

    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 the resulting arrangement as compliant with the GPL

    Please read the letter!

    I am providing my opinion in the present context to Slo-Media, which has retained me to give legal advice concerning the status of its intended product distribution.

    ---

  • by DarkEdgeX ( 212110 ) on Wednesday July 18, 2001 @12:40PM (#75929) Journal

    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.

  • the point is, the thing could become much more routine if nobody needed to trust a Special Master, which probably needs 'reasonable cause' or something. the thing could become routine this way.
    ~
  • What if you have a program which invokes some other GPL program (say, ls or bc) and uses its output ? The program is not 'linked' to it in the sense ordinary programmers use the term, and it is certainly arguable that the former program constitutes a separate entity from the GPL'ed program. But then again the programs are linked by their output and by their communication, and the former program relies on the GPL'ed program almost as surely as if the code was borrowed directly. Or does it ?

    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 ?

  • The result of this case sets the prescident that companies who wish to use GPL'd code can do so without releasing the bulk of the application in which the code is used, simply by partitioning their application and releasing under the FPL only the small partition of their app.

    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

    --
  • by WillSeattle ( 239206 ) on Wednesday July 18, 2001 @01:17PM (#75940) Homepage
    Given that Microsoft has been spitting out FUD in large quantities about the viral quality of GPL and Open Source, this result actually proves them wrong, in the way that everyone always said it would:

    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!

  • slahsdot need is good grammerer like me 2 help spel befor thnisg post & all wil be wel
  • 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

  • So even though we are destroying our rain forest, it's okay, because we're planting new tress?

    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.


  • What makes the harvesting of the rainforest so horrible is not the fact that we're decimating trees, but the delicate ecosystems that rely on them. Worse, when those ecosystems are effectively eliminated by a day's worth of chainsaw work, they are *not* allowed to regrow. Land stripped of trees is used for farming, and becuase of the poor soil conditions caused by the canopy of trees it once supported, that land can support 2 or 3 seasons worth of crops before it's completely stripped of minerals and nutrients that the crops need to thrive.

    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.
  • Here is a question that has been nagging me - how is it possible to safeguard against closed-source developers stealing GPL'd code?

    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.
  • Someone convicted of copyright infringement can be liable for up to $100,000 of statutory damages per infringement. Thanks, phr1, I was thinking about statutory damages but couldn't remember the number. Besides paying damages (real or statutory), the offender has to STOP infringing the copyright. Vidomi did that. Since they are no longer infringing, taking them into court over past infringement would be a lose-lose proposition. Since there is no lost revenue, the best that could happen would be getting the full statutory damages, and the lawyers would take that to cover their expenses and ask for their fees besides...

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

  • 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?

    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.

  • If they can't get the toothpaste back in the tube (i.e., if they can't recall ALL their binaries which violated the GPL), then they should have to release the offending source under the GPL. Wrong. The most a court could order them to do is to pay damages and stop infringing the copyright. (In other words, if you sold 1 million copies of a pirated Disney video, they don't make you go get those tapes back, but rather you've got to pay Disney for the sales they presumably lost -- and that's probably more than your gross revenue from the tapes.) Since you can't lose revenue on free software, in this case the cost would be the "statutory damages", which I've been told are now $100,000. I think that would pay _part_ of the cost of going to court. So once Vidoma has ceased infringing, filing suit would just enrich the lawyers.

    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!

  • Wrong. The first analogy I could think of was "I stopped after shooting off 3 of his toes, so that's OK, right?" Or if you were selling unauthorized copies of Disney's Snow White, Disney would want you to stop doing that, destroy all unsold tapes, pay them their catalog price times the number of tapes, and after bankrupting you thus they'd probably try to have you sent to prison on criminal charges too.

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

  • by Rick the Red ( 307103 ) <Rick,The,Red&gmail,com> on Wednesday July 18, 2001 @12:31PM (#75955) Journal
    Nothing here indicates the issue "has been resolved without going to court." Nothing except Vidomi's press releases, that is. Read the FSF "approval" and you'll see they simply say Vidomi's proposed solution will not violate the GPL. Says nothing about their previous violations and whether they will be sued over that. Which, I'm not alone in saying, I hope happens. But until we get a statement from the copyright owner that they will not sue Vidomi, this has not been "resolved without going to court."

  • A program linked by the end user at run time to a GPL library is NOT a derivative work!

    Perhaps. But what about a program developed using GPL header files allowing access to a GPL library?

  • no it doesn't. first, what is wrong with allowing the company to comply with the licence before any legal action is taken? just because they bundle the software with GPL code does not mean that if it is unbundled the propritary code is tainted and therefore must be released, the code was fixed, no harm no foul. and yes you can realese a plug-in under the GPL for a propriatary application since plug-ins are linked at run-time (at least that is the Linux way of handeling the issue (which most GPL developers agree with, unless they are hardcore GPLers). I think that you need to stop reading those GPL Docs on the M$ site and actualy read the GPL from cover to cover. ;)
  • by kypper ( 446750 ) on Wednesday July 18, 2001 @12:24PM (#75962)
    about the GPL.

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

  • Thats the general procedure.

    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.
  • by Derkec ( 463377 ) on Wednesday July 18, 2001 @12:31PM (#75965)
    I wouldn't be so quick there. First, it shows that GPL has to be taken seriously and can't simply be ignored. Further, it shows that GPLed code can be utilized by business as long as it is encapsulated. In other words, GPL be can be contained and doesn't infect IP in the way that Microsoft would have you believe. Now, I would hope that companies would have the decency to give back to the open-source community by working on the GPL code and not just exploiting it. It is with a differant binary, that's true. Unless I misunderstand things though, they stopped distributing the infringing binary and simply released the new split up ones. Overall, we really don't want to see companies that goof with GPL to go out of business. We want them to give back to the community while making some money and keeping any IP they find precious.
  • Who ELSE should correct the errors? Taco, et al, are paid living wages for their work on this site. That means it's a professional job, and maybe it's high time it should be.

    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.


  • 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 /without/ dragging it into the courts.

    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.

APL is a write-only language. I can write programs in APL, but I can't read any of them. -- Roy Keir

Working...