Subject: Re: balance
From: craig@jcb-sc.com
Date: 16 Oct 1999 16:46:48 -0000

>Sorry for the confusion.  What I am saying is that according to my
>understanding of the GPL, if I write a program that includes the line
>	#include "some_gnu_header.h"
>and some_gnu_header.h includes the line
>	extern void some_gnu_procedure();
>and my program includes the line
>	some_gnu_procedure();
>
>I have "copied" the name some_gnu_procedure from some_gnu_header.h and
>therefore the GPL requires me to place my entire program under the GPL, even
>if I don't distribute some_gnu_header.h, despite the fact that I could
>equally well substitute some non-GPL'ed file named some_gnu_header.h that
>declared some_gnu_procedure() for the GPL'ed one without changing one line
>of my code.  In other words, the GPL apparently attempts to assert that if I
>use a GPL'ed interface, I must GPL my entire program even if non-GPL'ed
>definitions and implementations of that interface exist.  In fact, the GPL
>apparently asserts that a non-GPL'ed definition of that interface would
>constitute copyright infringement, and that all implementations must be
>GPL'ed (because they use the names in the GPL'ed interface).

No.  The GPL doesn't assert that.  Most believe copyright law doesn't
assert that either.

IANAL, of course, but copyright law has been fairly consistently
adjucated as *not* applying to *functional* expressions, i.e. expressions
that are really the only functional way of achieving some thing.

So, in the specific case you mention, since there is no *other* way
to reasonably express an invocation of some_gnu_procedure() other than
to include that text in your code, you are automatically permitted
to do so.

IMO, if copyright law is *expanded* (through stupid court decisions
or stupid legislation -- not that I'm expressing an *opinion* on
that issue, eh? ;-) to include that sort of thing, then at least
two things happen:

  -  You can no longer write a review of a James Bond book, since
     that book contains the text "James Bond" and you copied it
     out of the book.  (Ignore the pre-existing nature of the books
     and such, this is a point for illustration only.)

  -  If the GPL can be easily modified to effectively revert its
     protections back to the state of copyright law *prior* to
     the expansion, it will be.  More likely, it can't, so what
     will happen is that header files will be modified (by their
     owners, e.g. the FSF for much GNU work) to explicitly grant
     the right to "copy" the procedure/macro/class/whatever names
     out of the file for the purposes of specifying their invocation
     in another work and of discussing them in conversation (etc.).


I'll also note that this belief that the FSF (not so much the GPL,
since it has no language saying this) "claims an interface copyright
an header files" used to be much more widespread several years ago.

If that's not where you got it, then, whoever you are, you can stop
reading here.  (Given how much I've written on this forum recently,
I'll be surprised if more than one or two people made it *this* far.  ;-)

The theory was that the FSF claiming it could/would succeed in
preventing a "user does the link" scenario being used to "get around"
the intent of the GPL -- e.g. a scenario whereby a proprietary chunk
of code is compiled into foo.o and distributed along with a Makefile
patch that changes a GNU program named bar so that when the *user*
invokes the Makefile, bar is built from source but links in the
restricted foo.o -- meant it *had* to be asserting what some called
an "interface copyright", which was the example you gave.

This theory was, IIRC, promoted exclusively by people who never once,
a single time, pointed to any actual writings by the FSF claiming
an "interface copyright".  It was a convenient straw-man, though
probably believed by some to be the only possible legal argument
the FSF could be, in fact, using.

But there's a difference between citing *evidence* of copying text
from a header file and actually claiming such copying was *illegal*,
just as the prosecution in a murder case showing that the victim's
blood was found on the suspect's shirt is a citing of *evidence*,
not a suggestion that having a blood-stained shirt (even of someone
else's blood) is, in and of itself, a crime.  (That sounds obvious,
but in the interface-copyright arguments on g.m.d, it was clear
many people couldn't, or wouldn't, get this logic and apply it to
what the FSF was claiming.)

The FSF used another argument, which is the "subterfuge" argument.  AFAIR,
it goes basically like this: what is, in fact, being distributed is
a program consisting of GNU bar and the code in foo.o; the mechanics of
the distribution don't change the fact that the distribution is of
an executable containing both GNU and proprietary code; the mechanics
of the distribution were, in fact, chosen *precisely* to create the
appearance of having *not* distributed GNU code, even though the
availability (via alternate distributions, or even the "mere aggregation"
clause) plus the modified Makefile and foo.o being usable as intended
only when linked with GNU bar assures that a modified GNU bar was,
in fact, distributed; therefore the mechanics of the distribution
constituted a subterfuge designed to get around the requirement that
a modified version of GNU bar, when distributed, must be distributed
under the terms of the GPL.

(I have really no clue whether this argument would fly in court.  So let's
not go there, as I can't participate, and have heard all the arguments
both ways -- unless there is case history in the past four years or so
that strongly suggests an opinion one way or another, in which case
post a URL or something.)

To continue the history...

If the FSF had claimed an interface copyright, it would have thereby
disallowed the cloning of any interface it created.  (Further, it would
have effectively taken the stance that *it* could not clone *proprietary*
interfaces, e.g. by looking at header files, or reverse-engineering
.o/.a files to see what the entry points are, etc.)

Instead, the FSF pointed out that if foo.o could be shown to be easily
linkable into a variety of programs and be effective, such that GNU
bar would be merely one of several (well, two or more) choices, and it
was therefore indeed up to the user to make an explicit choice to use
GNU bar rather than a non-GPL'ed program/library, then they'd have
no "subterfuge" argument and would not litigate.

That last point is particularly important, so I hope I have my history
right: the FSF didn't just say "well, we won't litigate that", but
said "it wouldn't be subterfuge, so we *can't* successfully litigate
that, so we won't try".

So if someone created a public-domain (PD) version of bar called pdbar
and distributed it reasonably widely, the distributor of the proprietary
foo.o code could compile it against pdbar's header files, have the Makefile
link in pdbar instead (and, unless distribution size is a problem,
include pdbar in the distribution), and be fine.  That the user might
go in and change the Makefile to link in GNU bar instead is then a
*user* choice, not a distribution choice.  (Yes, there's still some
fuzzy areas here, IMO: e.g. what if pdbar is so bad, i.e. buggy/slow/ugly,
that nobody in their right mind would use it?  At what point does it
become subterfuge?  The answer is: the law never provides a definitive
answer to edge cases like this, until all cases have been decided and
all appeals exhausted.)

Since pdbar, if created as a clone of GNU bar, would have to contain
the same names as bar's header files, it would clearly violate any
"interface copyright", if that existed.

Fortunately, it does not (to the extent the legal system seems to have
ruled on it so far), and the FSF in particular claims it does not.

All of the above scenario has happened at least once, and the part where
the FSF claimed it could and would litigate based on a subterfuge
argument happened another time.  That latter time, *real* lawyers on
the *other* side, with *substantial* motivation to challenge the FSF,
chose not to.  (The result was GNU Objective-C, so the FSF is not likely
to back down in the future just because a bunch of netizens agonize
about how awful the FSF is or how baseless the FSF's argument would
be in court, because they've already been down that route.  Besides,
especially as the Internet has become much more of a continuous-connection
beast, if the FSF stopped, or was stopped, preventing this sort of
"subterfuge", many of the GPL's most important protections would be
effectively stripped away in no time on a package-by-package basis --
because the friction preventing it would become much lower than it is
now.)

        tq vm, (burley)