Hi,
I am currently looking into using Drupal as a framework for Web
Application development. However, I was hoping that I could get some
clarification as to my potential obligations for modules that I would
develop under contract for my clients. My understanding according to
Licensing FAQ Question 8 (http://drupal.org/licensing/faq#q8) is that my
obligation under the GPL extends to delivering the module to the client
under a GPL license and that I am under no obligation to distribute it any
further.
Is that a correct reading of your intent with regard to that FAQ question
or have I misinterpreted/misconstrued your intent? I only ask because in
looking over the forums and the Free Software Foundations FAQ I am left
concerned that perhaps I have interpreted the question more favorably than
I should have.
In particular the following 2 questions from the Free Software Foundation
FAQ (http://www.fsf.org/licensing/licenses/gpl-faq.html) seem to argue
against that interpretation:
What does “written offer valid for any third party” mean in GPLv2?
Does that mean everyone in the world can get the source to any GPL'ed
program no matter what?
If you choose to provide source through a written offer, then anybody
who requests the source from you is entitled to receive it.
If you commercially distribute binaries not accompanied with source
code, the GPL says you must provide a written offer to distribute the
source code later. When users non-commercially redistribute the binaries
they received from you, they must pass along a copy of this written offer.
This means that people who did not get the binaries directly from you can
still receive copies of the source code, along with the written offer.
The reason we require the offer to be valid for any third party is so
that people who receive the binaries indirectly in that way can order the
source code from you.
GPLv2 says that modified versions, if released, must be “licensed ...
to all third parties.” Who are these third parties?
Section 2 says that modified versions you distribute must be licensed to
all third parties under the GPL. “All third parties” means absolutely
everyone—but this does not require you to do anything physically for
them. It only means they have a license from you, under the GPL, for your
version
Please let me know if you believe that my interpretation of FAQ question 8
is your overall intent or if I have misunderstood your goal with that
question and your policy regarding releasing modules.
Thanks for any help/clarification that you can provide.
Comments
Arguably, when you create a
Arguably, when you create a piece of code under the direction of a client or company, that client/company is the one who attains its copyright. It would therefore be up to them to decide if they wish to distribute it, and to adhere to the GPL if they do so. If it concerns you, you could explicitly place language in the contract you enter in with your client that specifies that they are the copyright holder on code you produce and therefore bound to the legal obligations and implications that goes along with that.
The Boise Drupal Guy!
Essentially correct
Whether you or the client holds the copyright to the code depends on your contract with them, and the specific laws in your area.
The FSF FAQ applies mostly to compiled code that has a separate binary and source form. If you distribute binary code to person A under the GPL, they are entitled to the source as well. If person A distributes the binary to person B, then person B is also entitled to the source. If you didn't provide the source to person A but provided an offer of the source upon request (which you can do), then person B is also entitled to request the source from you and you are required to provide it, even though you and person B never had any relationship before that.
Because Drupal, being PHP, is all interpreted code, the executable form is the source form, so that caveat doesn't apply. Distributing the PHP code to person A counts as providing the source. Person A is then entitled to distribute the code to person B if they wish, and person B then also receives it under the GPL, but neither you nor person A are under any obligation to provide it to person B in the first place. If you do, however, it must be under the GPL.
Naturally if the module is of general use then it's a good idea to release it on Drupal.org for all kinds of reasons, but it is not required that you do so.
Thanks for the Info.
Thanks to everyone who responded, that clears things up a lot. Also, I agree with regard to the benefits of Open Source, but I can't necessarily force everyone else to agree with me.
If you do, however, it must be under the GPL.
Not if I have copyright to the source. I can change the license with each distribution of the source. The biggest example I can think of is VA Linux and its alexandria project that is SourceForge.
Derivative work
Drupal modules are a derivative work of Drupal, and therefore must be released under the GPL, period.
If, however, there is a substantial (legal term) body of code in the module that can be easily separated from Drupal and still function, that can be released separately fro Drupal under whatever terms the copyright holder(s) want. As a Drupal module, however, it must be under the GPL.
Unsupported claim?
To my knowledge, this claim has not been affirmed by any court of law.
But you do make an interesting concession regarding a separated body of code. Does that finally suggest a solution to this question? Is this the way to prevent GPL from infecting my own proprietary code:
<?php
include("my_proprietary_code.php");
mymodule_nodeapi(&$node, $op) {
if ($op=='load') {
$node->mydata = my_proprietary_function($node);
}
}
?>
I then release an "aggregate" (legal term) with mymodule.module licensed under GPL and my_proprietary_code.php licensed under the license of my choosing.
Let's assume for the sake of argument that my_proprietary_code.php is fully capable of accepting input and producing output on its own, without Drupal, though I'm still not convinced that's relevant.
Obviously, this is not acceptable in the Drupal.org repository. That's clear enough.
And if anyone mentioned "shared memory space" I will scream, and then lick the soles of the shoes of the judge who gives a *&!# about that. It's completely irrelevant, in my opinion.
Drupal.org user profile
Drupal Micro-blogging: http://twitter.com/matt2000
No
It doesn't work that way. You cannot build a bridge to overcome the copyleft nature of GPL. If your module requires both Drupal and the proprietary code you cannot distribute your module. However, if you don't distribute the work, you can do whatever you like. The GPL mostly covers the distribution of software giving you the user the right to own the code to the distributed program. If your module requires the my_proprietary_code.php to operate and your distribute it under GPL then I have the rights to my_proprietary_code.php as well.
If your module requires the
That is incorrect.
You can't force a given bit of proprietary code to GPL by writing a 10-line program with a require_once() in it calling that proprietary code, and releasing the 10-liner as GPL'ed code.
<?php
/**
* This code is licensed under the GPL v2. Full text may be
* retrieved at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*/
function makeTypo3GPL() {
if (require_once('typo3/index.php')) {
print 'Typo3 is now GPL licensed.';
}
}
?>
Brian Vuyk
Web Design and Development
Long Sault, ON
http://www.brianvuyk.com | brian@brianvuyk.com
(613)534-2916
Brian Vuyk
Senior Developer, PINGV Creative
bv@pingv.com | (315) 849-9733 | Skype: brianvuyk
Correct
Right, you cannot force someone else's code to change to the GPL. Which in turn means that code you write that is a derivative of that work is also incompatible with the GPL. Similarly, Drupal code you write must be under the GPL as it is a derivative work.
So if you write something that is a derivative work of both Drupal (GPL) and something GPL-incompatible, then there is no legal way for you to distribute it without violating either Drupal's license or that other code's license.
The keyword is distribute
You can use privately derivative works that mix and mingle GPL and non compliant license all you want. You're risk of violation only comes if you distribute that mix and match derivative. RMS prides himself on the viral nature of GPL to open closed source. It is the very reason for GPLs existence. If you don't own the copyright of the proprietary source then you cannot distribute a combined work since you cannot change the license of the proprietary source.
If your module requires the
You must be understanding something wrong. Proprietary source remains proprietary. If I distribute a GPL'ed file which requires some proprietary code, that does not bring the proprietary code under the GPL. Rather, I've broken the GPL by distributing the mix in the first place. You can't relicense another person's work without their knowledge.
--
Brian Vuyk
Web Design and Development
Long Sault, ON
http://www.brianvuyk.com | brian@brianvuyk.com
(613)534-2916
Brian Vuyk
Senior Developer, PINGV Creative
bv@pingv.com | (315) 849-9733 | Skype: brianvuyk
Ownership of proprietary code
The key question is who owns the proprietary code. If someone besides you does, then there is no legal way for you to distribute the "double-derivative" code without violating someone's license.
If you own the code in question, then the only way you can distribute that code comingled with GPLed code is to GPL the whole thing. (The parts that you hold the copyright to you can distribute separately somewhere else under whatever license you like.) By distributing it comingled with GPL code, the natural presumption is that you are distributing the whole thing under the GPL as that is the only legal way to do so. Most people will assume you are not, in fact, violating someone else's copyright on the GPLed code.
If you claim not to, then that's where the violation comes in and the exact solution varies depending on the parties involved. Generally, what usually happens is either you stop distributing the code at all and everyone growls and goes home, or you go ahead and agree to release your code under the GPL so that you can continue to distribute it comingled with the GPL code. There may or may not be lawyers and lawsuits involved, depending on the case. Preferably there aren't. :-)
"With all due respect" here,
"With all due respect" here, you do not seem to understand what a "derivative work" for purposes of US copyright law.
Citing Wikipedia-- not the best of sources, but it will do:
A “derivative work” is a work based upon one or more preexisting works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which a work may be recast, transformed, or adapted.A module as in the example above does not (necessarily) substantively 'recast, transform, or adapt' Drupal in the sense above, no more than a program running on a MicroSoft OS or in C+ is a "derivative" work of those systems for purposes of the copyright law. And distributing such code separately (as opposed as in a complied or bundled form) would seem to leave the distributing party with no obligations under the GPL.
In short, an independent module is NOT a derivative work of Drupal as defined by most copyright legislation.
~kwt
~kwt
Drupal modules are a
Uhm, I don't see how they can be a derivative work of Drupal. They are an independent work dependent on the Drupal API. A derivative work of Drupal would be a fork of Drupal. However, because the module depends on and cannot operate without Drupal, the work must be licensed as GPL because Drupal is licensed as GPL.
I tend to like the preamble terms "This module's license is governed by the license of Drupal." This gives Drupal the right to relicense the module should it care to.
earnie, You write: I don't
earnie,
You write:
I do not (quite) see your logic here.
One could argue that this is simply a matter of contract law, that is, if the user accepts a copy of Drupal, that the user accepts the licensing terms associated with the copy, which state that 'a module' is subject to the GPL (because it is a derivative work, or such).
This legal theory is subject to two potential assaults:
1) Frontal, that is, one could argue that there are circumstances, fair use or otherwise, which allow use of the Drupal code without becoming subject to the license terms. (I'll skip further elaboration, but this would be the case in jurisdictions where the code is not subject to copyright, for instance).
2) Via the definition of "derivative work," which you cite above. a) Drupal's default definition of derivative work is that of the GPL; as you state, since the modules are not derivative under this definition (statically linked or compiled, etc), this is hard to see in itself; b) "derivative work" is, after all, a legal term with a life and definition outside the GPL, and many courts may be unlikely to grant the GPL the ability to redefine the nature of "derivative work" willy-nilly, into whatever it wants (again, you start by saying this, essentially).
Finally, even if one grants a definition under "contract law," the wording of the GPL is not such that the "violation" would be anything but a matter of contractual violation between two parties, that is, it would not rise to a matter of copyright, trademark or other law, and invoke the civil and criminal penalties and sanctions proscribed in such; it would merely be a contract violation between two parties. In practice this means that the grounds of causes of action would be curtailed, though I'm not going to speculate as to how.
Regardless, in the end, this means there is quite a difference between a manufacturer such as Sony releasing equipment that uses code clearly written under the GPL (as intended by the code author), and a single independent author writing his or own "module code," which is a 'substantively new and original work" as recognized by the copyright laws, and refusing to explicitly extend the GPL that original code.
One can imagine that an individual who has never downloaded or run Drupal code (and thus never theoretically become subject to the Drupal license), downloads module code that does not contain a GPL licensing statement. In this instance, the horse seems out of the barn-- it is hard to imagine how future copies become subject to the Drupal form of the GPL.
In short, the argument that "Drupal module code," absent explicit declaration by the author, somehow magically becomes subject to the GPL because somewhere, somehow, it is run under Drupal (by whom? when, where, and how do you prove it? by a third party?)-- remains fairly weak and full of holes.
~kwt
"released" or "licensed"?
Shouldn't that be "therefore must be licensed under the GPL" instead of "therefore must be released under the GPL"?
Chris, Well-- "released under
Chris,
Well-- "released under the GPL" is the common phrasing, and implies that any work released under the GPL should also be "licensed under the" terms of the "GPL."
But see above.
Ken
~kwt
Ok, I'm a bit confused
So let me see if I get this...
Example:
A client of ours wants a website, and we obviously want to use Drupal. But they want some specific functionality provided by a PHP package not released under GPL (or a GPL compatible license).
If we write a custom module that would use this functionality, we would be distributing it to the client, right ? So everything would have to be GPL. So in our case, we'd be violating the GPL license ?
Or, if we assume the client obtains all the rights to the module (by contract), as this module will never leave their server, is this ok ? But we have to give them the full rights to the module, and all custom PHP Classes we might have written in the past that we re-use within it (eventhough they are not dependent on Drupal).
Or, would we have to create a webservice using a SOAP (or other) "bridge" so that the module and the proprietary code remain separated ? (License FAQ question 10)
Sorry if this question seems overkill, but all these comments above confuse me :-).
I'm on Twitter, y'all
I blog about Drupal'n'stuff
Depends :-)
That depends on the details of the contract between you and your client for whether #1 or #2 applies. I'm not an attorney so I cannot comment on the specific fine details of that point. You'd want to check with a real Free Software-savvy attorney on that front. (Not just any copyright attorney, one who is familiar with OSS licenses. Many that are not are knee-jerk hostile to it, so make sure you don't get one of those.)
Yes, consult an attorney :)
Crell is essentially correct here-- if you are serious, you should consult an attorney who knows what they are doing (and who is neutral, not hostile). If you do not know one, I'd be glad to locate one for you.
~kwt
Thanks for your replies
Thank you guys. Well, it was just an example. But I'm sure this kind of situation will present itself one day, and surely has presented itself for many companies using Drupal. I wonder if any one with any experience in this matter would share his findings here. This would be great, as Drupal can be used for so much more than just site content management ! The possibilities are endless, even more if we can use any libraries with it, regardless of the license (because there's not always an open-source alternative to some of the proprietary ones).
Anyway, thanks !
I'm on Twitter, y'all
I blog about Drupal'n'stuff