Drupal, GPL and module development
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.
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.
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.
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
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
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. And distributing such code separately (as opposed as in a complied 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.
~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.