Subject: Re: Still puzzled by GPL if used with proprietary run-time libraries
From: craig@jcb-sc.com
Date: 13 Jul 1999 19:43:00 -0000

>Is it allowed to put a GPL on our programs when using (for now) Delphi as
>our development environment. When using the software package you need some
>libs from Borland which are not free.

When they're *your* programs, I think it might well be the case that
you can distribute them anyway.  (IANAL, however.)

The GPL is written around language such as "a work".  You, as author,
get to determine what constitutes "a work", referred to as "the Program"
mostly (with suitable definition).

By distributing your program under the GPL, you "annoint" it as "the
Program", even if it is not what would normally be considered a "program"
by the user community.

Now, by doing this, you permit anyone to distribute your work under the
GPL even if they have to hook it up to proprietary libraries to make it into a
complete program, because they're reproducing *your* "Program".

The recipients of these redistributions still have the same rights the
original distributor (you) had, so it doesn't violate the GPL.

This issue is a bit confusing because of the gmp (GNU Multi-Precision library)
issue, or whatever it was called, which was under the GPL.

There, someone wanted to, in effect, distribute a work that was the result
of combining the gmp with another library (RSAREF?) that was licensed in a
way incompatible with the GPL.  (Plus some other free code they themselves
had written, I gather, but not put under the GPL.)

They tried to get around this by leaving it to the user to perform the
actual combination of the components ("user does the link" was the phrase
coined around that time, I believe), using an essentially fully automated
process.

The FSF basically argued, in public (to support their legal stance), that
this method amounted to a sort of subterfuge -- that there was no
useful purpose to this method of delivery, compared to delivering a
pre-linked executable, *other* than to work around the fact that it
violated the two library's licenses to distribute a work containing
both of them (i.e. you couldn't distribute gmp under terms of RSAREF,
and vice versa -- people sometimes prefer to state this as "GPL prevents
distributing code with other licenses", but it's *always* a two-way
street, since, if those other licenses were at least as "free" as the
GPL, in the superset/subset sense, there'd be no conflict, as the
GPL does not forbid being combined with other code based simply on
whether it is licensed under the GPL).

Anyway, I believe the FSF would not have objected, or at least would have
had no case, if the *method* had remained the same but the GPL'ed *library*
had also been owned by the person making the distribution.

In that case, we'd have this scenario:

  Joe Blow owns both program MYRSA *and* library MYMPLIB.  For them to
  be useful as an executable program, proprietary library RSAREF must
  be linked with the others.

  However, Joe Blow decides to distribute MYRSA and MYMPLIB under the
  terms of the GPL.  (Or just MYRSA, having previously distributed
  MYMPLIB.)

I believe *that's* okay, because it's Joe Blow who gets to decide what
constitutes "the Program" under the terms of the GPL, by virtue of
making (or having made) the MYMPLIB distribution.

(However, I must say here, I'm viewing this entirely from the point of
view of the GPL, or the FSF.  The RSAREF people might claim this is
*not* okay, because they don't want *source code* that they consider
to have *derived* from RSAREF to be freely distributable, since that
might encourage attempts at writing clones.  I'm not saying they'd
succeed at preventing this, but they could certainly try.)

So, if Joe Blow distributes MYRSA and MYMPLIB as GPL'ed source code,
any *other* person can do the same without legal conflict, and can
choose to link with RSAREF (assuming they have legal access to a copy),
or any other library, or simply peruse the source, whatever.

Whereas, the *actual* situation with gmp was that, in essence, *Mary Inhale*
(being polite here ;-) owns MYMPLIB.

So, Joe Blow is, when it comes to the MYMPLIB portion, merely
*re-distributing* MYMPLIB, if he distributes it at all.

More importantly, though, is the fact that Joe Blow is distributing
a work that *derives* from MYMPLIB -- specifically, MYRSA.

By distributing MYRSA along with scripts to automate the "user does the
link", even without MYMPLIB itself, Mary Inhale argues that Joe is effectively
distributing a work that derives from her MYMPLIB, but which end users cannot
redistribute under the same *effective* terms (that is, the same terms
under which they ended up with a complete, working, program, which Mary
correctly asserts is, itself, derived from her MYMPLIB).

Mary can claim this (with legal stance, I believe) only as the copyright
holder of MYMPLIB, in which case *she* gets to (try to) define what
constitutes a "work based on her Program".

So Mary might claim that MYRSA+MYMPLIB+RSAREF constituted a "work based on"
MYMPLIB, and therefore merely distributing *MYRSA* constitutes distributing
a work based on MYMPLIB, because the intent is to deliver to end users a
work based on MYMPLIB, but which they cannot distribute themselves -- a
requirement Mary specifically put on her code by putting it under the GPL.

(Whether Joe, or others, are distributing a work based on MYRSA and/or
RSAREF is not for them to say.  Joe can say that vis-a-vis MYRSA, and
the owners of RSAREF can say that vis-a-vis their product.  So someone
distributing MYRSA could be told they're distributing a work based on
all three products, which is certainly feasible, though two of them --
MYRSA and MYMPLIB -- *permit* such redistribution, except for the fact
that the third -- RSAREF -- does not permit redistribution under the same
terms.)

In summary, if *you* are the owner of the code, and it does not depend
on other GPL'ed code in a sense that the owners of that code would
consider to make your code "derived" from it, and ditto for what *other*
code your code depends upon, then it should not matter that a complete,
working executable cannot be legally distributed because of license
conflicts.

In essence, the issue comes down to whether you and the owners of the
libraries in question agree that the collective license terms you're
using conflict.  If the owners of Access don't mind you distributing
source code that uses their product under the GPL, and ditto for the
owners of Delphi (or whatever), and *you* don't mind your source code
being redistributed under the same terms (the GPL), then you should be
fine.

Now, why might *you* mind?  Well, suppose you wanted to distribute under the
GPL to attract the supposed wonders of OSS development -- salivating,
expert developers, whatever -- but you wanted to charge license fees
on a per-copy basis anyway.

You might think "aha, I can solve this problem by shipping the bulk of
the code under the GPL, but having it make fairly crucial use -- say
to write out the document my product lets a user compose -- of a library
that, itself, is proprietary and for which a per-user fee is charged;
then I can enter into an agreement with that library vendor to get a cut of
those charges".

That'd work, at first, but you'd have no way to prevent people from linking
your program to *another* library that was compatible with the one you chose
but that didn't give you a cut.

Whether that new library was GPL'ed or not wouldn't be the issue.  Since
you distributed your code in the form you chose, *you* designated that
"the Program" did not constitute a complete, working program -- since
you yourself distributed it that way.  (And, unlike MYMPLIB, aka gmp,
they couldn't trivially make it into a working program by linking it with
a number of possible "suitors" that properly exploit its facilities.
The gmp/RSAREF issue was "solved", in the view of the FSF, once another
library, compatible with both gmp's interface *and* with the GPL, was
developed, even though it ran much slower, because that meant MYRSA,
or whatever it was called, was no longer clearly derived from gmp itself.)

So, anyone can choose to link any other library to your code without having
created a "work based on the Program", as long as they don't redistribute
it as such.

They can even attach a alternate, GPL'ed, chunk of code to your code,
or even *patch* your code, so it no longer needs the proprietary library
upon which you're depending for revenue.

So as long as you don't mind your product being *improved* by others,
and *redistributed* in that improved form, so it no longer needs Access
or Delphi or whatever, you should be fine distributing it all under the
GPL.

But, I would suggest you not call it "Open Source" (TM) software, since
it might not meet the definition.

        tq vm, (burley)