That is, it's not even a final decision of a court.
So while interesting, it's incredibly early in the process. The same court could issue a ruling going the exact opposite way after trial.
As someone else wrote, basically a court rule that a plaintiff alleged enough facts that, if those facts were true, would give rise to an enforceable contract.
IE they held that someone wrote enough crap down that if the crap is true the other guy may have a problem.
They didn't actually determine whether any of the crap is true or not.
(In a motion to dismiss, the plaintiff's allegations are all taken as true. This is essentially a motion that says "even if everything the plaintiff says is right, i should still win". If you look, this is why the court specifically mentions a bunch of the arguments the defendant makes would be more appropriate for summary judgement)
Is "preliminary injunction" the right terminology here? It sounds like it was a motion for dismissal.
Anyway, it's appalling how often the press confuses pre-trial motions like this with substantive rulings on the issues of the case.
...and it is also, sadly, no surprise that they also think that this sets precedent. Why is it so hard for them to understand the difference between trial courts and appellate courts and which set precedent?
Newspaper should be read like a novel that is "based on true events".
As for press, yeah, it's frustrating and annoying, but such is the 24 hour news cycle
Trial courts also set precedent. It doesn't carry the same weight as appellate court precedent, but their rulings do have precedential value.
In all that we do at Quartz, we embrace openness: open source code, an open newsroom, and open access to the data behind our journalism.
Alternatively, Hancom could pay Artifex a licensing fee. Artifex allows developers of commercial or otherwise closed-source software to forego the strict open-source terms of the GNU GPL if they’re willing to pay for it.
This obligation has been termed "reciprocity," and it lies at the heart of many open source business models.
http://www.rosenlaw.com/pdf-files/Rosen_Ch06.pdf
The more important issue here is reciprocity, not whether an open source license should be considered to be a contract.
AFAIK, the reciprocity provision of any version of the GPL hasn't been tested in any meaningful way within the US. In particular, the specific use cases that trigger reciprocity remain cloudy at best in my mind.
Some companies claim that merely linking to a GPLed library is sufficient to trigger reciprocity. FSF published the LGPL specifically to address this point.
So I believe a ruling on reciprocity would be ground breaking.
It seems like "reciprocity" has an even worse outcome than BSD source code. The origin of the source code can be completely hidden from the user.
Do users deserve to know at least that the original source code was freely available? What happens when users discovers that they are paying for something that others are getting for free? Do they care?
Is this a case of taking something that was free (but valuable), i.e., the original GPL source code, and concealing it as a closed source work in order to generate revenue/profit for some specific person or entity?
Stupid question: If someone fixes or adds something valuable to GPL source code and wants to charge for it, then why not just charge for the patch or the additional code?
(Assume that patches or additional source code files are distributed by themselves without the original GPL source code and that they do not contain any functional portion of the original GPL source code. Assume further that they do not use "interfaces" designed by the GPL source code author. Finally, assume that the end user can compile their own software and no binaries are distributed.)
Reciprocity means a mutual or cooperative interchange of favors or privileges. Something is reciprocal when it is performed, experienced, or felt by both sides. (The American Heritage Dictionary of the English Language, 4th edition.)
The GPL license is reciprocal, because it is “performed, experienced, or felt” by both sides—the licensor and the licensees both use the GPL.
In non-legal terms, I'd put this as "the GPL allows you to redistribute in kind: by extending the offer the original licensor made to others." The "price" of redistribution is agreeing to public participation in the co-evolution of the software.
This is not to be confused with Artifex's offer to dual-license: you may either accept the terms of the GPL or purchase a commercial license. These two worlds do not interact other than Artifex, the copyright holder, uses its rights under copyright law to offer these two alternatives.
So while writing this comment I remembered the old case of QT and found this article (https://www.fsf.org/blogs/rms/selling-exceptions). To quote it similar to a "inferior choice, but it's not wrong".
You can legally do this, but it will not be easy. You cannot distribute a binary in this way, if you do your patch becomes GPL so the first person who buys your patch can legally give it to everyone else. That means you have to sell the source code to your patch and your customers have to build the binary themselves. You need to ensure that your customers understand that they cannot distribute any binaries they make. (they probably can distribute it within their company but they need to have some process to ensure that their employees know they cannot distribute this)
If anyone is thinking about this, make sure all sales include your lawyer: you will need to ensure that your customer understands all the subtleties otherwise the courts might decide your patch is GPL.
I've often thought that this was a pretty ideal way of licensing OSS.
It provides a revenue stream for improving upon open source from those with the deepest pockets and the greatest ability to pay which clearly works (QT, for instance, probably wouldn't exist without this model).
Moreover, it doesn't remove others' freedom to be able to develop free software from it.
It's telling that the biggest whinges about the GPL often come from large (often abusive) corporations with deep pockets, an inflated sense of entitlement, paranoia about "their" intellectual property and a desire to get freebies from ordinary developers.
As for Stallman's intentions, he's talked about this exact model: https://www.fsf.org/blogs/rms/selling-exceptions
You can sell it, but it's still subject to GPL.
Distribution of binaries is a bit of a diversion here, and not a key issue - it dorsn't really matter if we're talking about C or python.
Nothing is stopping someone from paying the rights owner of a BSD-licensed work for the right to use it without preserving the copyright notice. The analysis is the same as for a GPL-licensed work.
If the argument is that it's better to have BSD-licensed works without paid exceptions than GPL-licensed works with paid exceptions, well... first off, nothing stops the paid exceptions from being "You can use this under the BSD license". Second, this seems like a strategic thing; if most users comply with the GPL, and you raise some money, that seems like a net win compared to everyone complying with the BSD and not providing source despite not paying.
> Assume further that they do not use "interfaces" designed by the GPL source code author.
I'm having a lot of trouble imagining a patch that works this way. If you're patching the program, aren't you interfacing with the program somehow?
I can think of two possible ways. One is that you're actually patching other interfaces (e.g., providing an LD_PRELOAD) provided by more-liberally-licensed software. I don't think that an LD_PRELOAD of POSIX interfaces intended for use with specific GPL software is a derivative work, but I also don't super look forward to convincing my lawyer of what's going on, let alone a judge.
The second is that you're running the program in such a way that you're really wrapping standard I/O and not touching the program itself, but I wouldn't call that a patch. JuiceSSH for Android does this with mosh, for instance; it uses an upstream mosh-client binary (and provides source) in a subprocess of its proprietary UI. On a system like iOS where you can't fork, I could imagine some scheme for running the process in the same address space with some serious emulation. I very much wouldn't look forward to litigating this; it sounds sorta like the VMware lawsuit, which is a huge mess.
If you're providing a plugin through a defined plugin interface, and the software author has said "Use of this plugin interface doesn't subject you to my program's license" (or the plugin interface is an external standard like VST), then you're in the clear. It's worth noting that Linux has an explicit statement that the syscall interface does not subject userspace programs to the GPL. I don't know if such a statement is necessary, but it's nice that it's there. But these sorts of things are definitely not what I think anyone would call a "patch".
Nothing stops anyone from charging for the GPL code in the first place.
As to your question, you've already agreed not to charge for your patch by the fact that you've utilized the GPL to access the code in the first place. That's one of the points of the GPL after all.
Probably not. Although from what I've seen, he was rather short on explaining how devs would make money to support themselves under GPL.
Contract terms should be up next (but I smell a settlement, frankly).
From your ethical perspective, yes. From a court's perspective, reciprocity can't be enforced without the existence of a valid contract because there is no legal obligation for people to be nice to each other. Contracts are the mechanism we use to establish obligations between private parties.
Reciprocity and the conditions that trigger it (I link to your GPL library and so must release my application source code) has never been ruled on from what I've seen.
The GNU GPL was written on the basis that if someone does not accept its terms, then that without any other license from the copyright holder, redistribution puts that person in violation of copyright law.
Suing for damages on the basis of a breach of copyright law clearly does not require any contract.
So this is more about a technicality of the legal process in this particular case, rather than anything about whether copyleft is legally enforceable or not in general.
Specifically, because the motion denial was based on the defendant's own admission being deemed to be the agreement of a contract, this says nothing about the general enforceability of the GPL (future defendants could simply avoid making such an admission).
Further, since the ruling was in response to a specific motion, it only concerns the claims made in that motion: about whether a contract exists in this particular case. It says nothing about the "copyright violation if you don't accept the license" mechanism of copyleft.
Finally, the article does not provide any evidence that there has been any ruling that determined that the GPL is an enforceable legal contract, contrary to its title. The ruling as quoted just says that the defendant, by its own admission, did accept to enter in to the GPL-defined contract.
Because the GPL license is the only thing granting them the rights to use that intellectual property, right?
It may be a technical violation. This wouldn't in itself make any difference to anything, however. It would only matter if a court would then award damages to copyright holders as a consequence of the violation. A violation in civil law doesn't mean anything in practice except when damages are awarded (and only changes behaviour when damages could be awarded).
Damages are awarded based on harm done. I think a copyright holder would struggle to show that any harm was done by the defendant, especially as the defendant would have been acting in good faith. Of course this depends on the details of the reason the court ruled the GPL invalid, so it's not really possible to speculate on your hypothetical further.
https://docs.justia.com/cases/federal/district-courts/califo...
The judge ruled that the claim of breach of contract cannot be dismissed on the basis that the contract does not exist, because the defendant has effectively admitted that it did exist.
The judge also ruled that the claim of copyright cannot be dismissed on the basis of jurisdiction.
None of these things relate to the enforceability of the GPL in general.
I came here to say basically this. To make this really explicit - this result is completely and utterly unsurprising and does not set any new meaningful precedent. Nothing specific to the GPL was implicated.
Using someone else's source code without permission has always been, and continues to be a violation of copyright law.
Any judge in the country or anywhere else would laugh a GPL challenge right out of court. Any any IP lawyer reading it would tell their client that that's what's going to happen if they try to challenge it. That's why it's never been fully tested in court... no need.
To the first point: the GPL is not used nearly as much as it should be. Thus there's still a strong selection bias on court cases in general being about the GPL, since the GPL is not selected very often. (And there's a reason it is avoided: legal counsel to large companies frequently describe the GPL as "untested." This happens still today, which is frankly ridiculous in the light of all that the Software Freedom Law Center, FSF, etc. have done)
To the second point: any court proceeding introduces a huge amount of uncertainty. Costs are up-front, payback may come in a decade or more after all routes of appeal have been exhausted. Judgments are frequently overturned on technicalities; even if the technicalities are flawless the GPL is not unassailable.
On a personal note, I am unequivocally in favor of using Free Software further and wider than it has been used. In every potential conflict of interest, I think there is much to be said for attempting to settle with a "GPL violator" using amicable means, even if it takes a long time. I view "GPL violations" as free advertising -- don't be shy about publishing the proceedings, though doing it with some taste may help the party come into compliance, their actions should speak for themselves!
People use GPL software, extensively.
Any use of GPL software is a compliment to the software authors.
Any contribution back to the software will improve it for everyone.
etc.
... so they admitted to the court that they willfully used the software without a license to do so?
To decide such a motion the court assumes that every fact alleged by the plaintiff is true, and then looks at each charge to see if all the necessary facts to support that charge are covered. If some charge is not covered, then that charge can be dismissed.
So what is happening here, it sounds like, is that the defendant is saying that plaintiff did not allege that defendant signed anything, and the defendant seems to think (for some reason I do not understand...) that you have to sign something in order to have a contract, and so wants the court to dismiss any charges that require there to be contract.
The court said that plaintiff has in fact alleged sufficient facts for there to be a contract, so denied the motion to dismiss.
I know, right? I'm really baffled that any lawyer would even try that argument. That's like, first or second week of first semester contract law right there.
What's funny is that Hancom is essentially arguing that shrink-wrap licenses (contracts) are unenforceable. Ghostscript was open sourced under the GNU GPL which states, in shrink-wrap fashion, that use of the software without an explicit commercial license binds the user to the GNU GPL. Integrated the software into their own closed-source software and distributing said closed-source software is unquestionable use.
At the same time, you can guarantee that Hancom would fully enforce their own shrink-wrap licenses - Terms of Use, Terms of Service, etc. - on others.
However, GPL still works in such jurisdictions since if you claim that you don't accept GPL then you're violating the copyright law by distributing without a licence to do so. General shrink-wrap licences can't use this logic because (in those jurisdictions?) using software or service doesn't require a licence, unlike copying.
A typical "EULA" attempts to reduce your rights, without any further consideration from you (you'll have already paid for it, etc). If you disagree, the authors like to claim that you are bound by their more restrictive terms anyway. That is what is legally dubious.
A copyleft license does the opposite: the software comes with an offer to grant you additional permissions should you choose to accept its terms. You have the option to decline, and nobody is claiming that your rights are in any way further restricted if you choose to decline.
Put another way, you are free to use GPL software without accepting the terms of the license. But if you don't accept the terms, then you violate copyright law every time you make copies of it.
Not quite technically!
The way it works is: you have no permission by default under copyright. The only permission you have to copy is the GPL. If you obey it, fine. If not, you're just violating copyright like any other copyright violation.
This can be an important point: it's a license, not a contract.
It may be unfortunate that the judgement uses the word "contract", presumably because that's the word the defendant used.
Defendant (Hancom) was trying to say that because they didn't sign anything they didn't have a contract.
But Hancom "represented publicly that its use of Ghostscript was licensed under the GNL GPU"
Therefore, the Judge ruled that in their own words they publicly acknowledged the contract.
Common law judges are very prudent in their ruling.
https://docs.justia.com/cases/federal/district-courts/califo...
Also, the article doesn't say much about how that lawsuit came to be. Did Artifex approach Hancom beforehand to notify them about the license infringement or just directly sue? I guess in this particular case, Hancom knew what they were doing, but I can imagine some (smaller) companies not being fully aware of open source license specifics and unknowingly running into a lawsuit.
This is not a real problem until there are licensing trolls, where their sole purpose is to make money off of breaches.
If a company receives a lawsuit, they can claim ignorance and start to comply with the contract. This would change it into a minor breach of contract, where they would only be liable for actual damages caused. Actual damages would either be nothing or fairly impossible to prove, so the lawsuit would likely be dropped.
Most of the time lawyers advise the policy that you don't register until you are ready to sue for a violation. You only get actual damages but this is typically enough. However if you believe someone is actually going to violate your copyright (or you want to spend $25 + plus lawyer fees) you should register before you release software: you will get triple damages.
I'm not sure what damages means in terms of the GPL though. In the case of a book you can say the book sold for some amount of dollars so every sale of your illegal copy cost me that amount of dollars.
Are you sure claiming ignorance would make a difference? I tried to google it and found the Wikipedia article on "Ignorantia juris non excusat"[1], which claims that in most countries, not knowing a certain law provides no protection whatsoever.
people who are likely to steal code are unlikely to audit it sufficiently to identify esoteric behaviour.
That gets awfully close to DRM, though.
printf("Could not open ghostscript project %s", project)
You could find the "Could not open ghostscript project %s" part in the binary?
https://en.wikipedia.org/wiki/BusyBox#GPL_lawsuits
In one enforcement, the defendant defaulted and the SFLC ended up with a pile of violating televisions!
http://www.groklaw.net/article.php?story=20100803132055210
The enforceability of the GPL is in no way news. That anyone would continue to try to violate it is the real WTF.
It's fairly clear that they will win the case in one fashion or another. I am predicting that the case will quickly be settled out of court for a lump sum plus a running licensing fee. You have a public admission from the defendant that they integrated the plaintiff's Ghostscript software into their own without either: 1) making the resulting Hancom office suite open source, or 2) paying Artifex a licensing fee for the software.
The case against Hancom was solid under copyright infringement, and now has the added sting of breach of contract.
And the attitude is almost always myopically limited to the GPL. Would you react the same way to a suit that substituted the infringement of Microsoft copyright? "Microsoft sued someone for infringing their copyright, so now I'm scared to link their code" doesn't pass the giggle test.
Ask HN: What if the vendor had structured their product in a way that GhostScript is its own stand-alone app. Would they still be obligated to release their entire code, or just the portion that uses GhostScript?
I believe they might need to allow for others to download the source of Ghostscript whether modified or not, but that part isn't hard. :)
https://scholar.google.com/scholar_case?case=377952933561079...
It is simple to work around licence issues with your project. You just have to put in the work. Know that your design may have to factor in extra time because you can't use lib XYZ because you have to write your own library to do the same thing. If using lib XYZ will save a bunch of time, then know that you will have to adhere to lib XYZ license. Maybe writing a wrapper application that you opensource, and your closed source application interfaces with might be a design consideration.
In the end, it's your project, your call. Just know when you make a decision you weigh the pro's and con's of going forth with that decision.
So the suit was filed only after Artifex had notified Hancom of the license and attempted to work out a solution out of court. There's no way to argue they didn't know about the license beyond a certain date, and it sounds like they willfully continued to infringe upon the license after said date.
So they either accepted the GPL or violated copyright.
On a procedural level, understand that this is a district court opinion and is not binding on any other court. Of course, if other courts find the arguments persuasive, they can adopt the reasoning. But no court has to adopt the reasoning in this opinion.
On a substantive level, it's important to look at the arguments the court is addressing and how they are addressed:
1) Did the plaintiff adequately allege a breach of contract claim?
We're at the motion to dismiss phase here and the court is only looking at plaintiff's complaint and accepting all of the allegations as true.
There are essentially only 2 arguments the court addresses: A) Was there a contract here at all?; and B) Did the plaintiff adequately allege a recognizable harm?
Understand that in a complaint for breach of contract, a plaintiff has to allege certain things: (i) the existence of a contract; (ii) plaintiff performed or was excused from performance; (iii) defendant's breach; (iv) damages. So, the court is addressing (i) and (iv), which I refer to as (A) and (B) above.
As to (A), the argument the defendant appears to have made is that an open source license is not enforceable because a lack of "mutual assent." In other words, like a EULA or shrink-wrap license, some argue that an by using software subject open source license doesn't demonstrate that you agreed to the terms of that license.
The court, without any real analysis, says that by alleging the existence of an open source license and using the source code, that is sufficient to allege the existence of a contract. The court cites as precedent that alleging the existence of a shrink-wrap license has been held as sufficient to allege the existence of a contract.
But the key word here is "allege." As the case proceeds, the defendant is free to develop evidence to show that there was no agreement between the parties as to the terms of a license. So, very little definitive was actually decided at this stage. All that was decided is that alleging that an open source license existed is not legally deficient per se to allege the existence of a contract.
As to (B), defendant apparently argued that plaintiff suffered no recognizable harm from defendant's actions. The court held that defendant deprived plaintiff of commercial license fees.
In addition, and more important for the audience here, the court held that there is a recognizable harm based on defendant's failure to comply with the open source requirements of the GPL license. Basically, the court says that there are recognizable benefits (including economic benefits) that come from the creation and distribution of public source code, wholly apart from license fees.
This is key - if the plaintiff did not have a paid commercial licensing program, it could STILL sue for breach of contract because of this second type of harm.
That being said, none of this argument is new. There is established precedent on this point.
2) Is the breach of contract claim preempted?
Copyright law in the United States is federal law. Breach of contract is state law. A plaintiff cannot use a state law claim to enforce rights duplicative of those protected by federal copyright law.
So, what the court is looking at here, is whether there is some extra right that the breach of contract claim addresses that is not provided under copyright law.
In other words, if the only thing that the breach of contract claim was addressing the right to publish or create derivative works, then it would be duplicative of the copyright claim. And, therefore, it would be preempted.
Here, the court held that there are two rights that the breach of contract claim addresses that are different from what copyright law protects: (A) the requirement to open source; and (B) compensation for "extraterritorial" infringement.
The real key here is (A), not (B). With respect to (A), the court here is saying that the GNU GPL's copyleft provisions that defendant allegedly breached are an extra right that is being enforced through the breach of contract claim that are not protected under copyright law. Therefore, the contract claim is not preempted.
(B) is a bit less significant for broader application. What (B) is saying is that because the plaintiff is suing for defendant's infringement outside the U.S. ("extraterritorial" infringement), and federal copyright law doesn't necessarily address such infringement, that's an "extra element" of the breach of contract claim. I say this is less significant because it wouldn't apply to a defendant who didn't infringe outside the United States. So, if you were the plaintiff here and the defendant was in California and only distributed the software in the U.S., argument (B) wouldn't apply.
I hope this clarifies what is/is not significant about the opinion here.
Hancom's CEO is a thief.
