[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

Re: [GPL] No linking with proprietary programs: where?

On Wed, 15 Mar 2000, Marcus Brinkmann wrote:

> > What is this subtle difference ?
> Piping is done by using both components in a bigger structure (the pipe is
> added by the user, not something that is provided by either application).

That isn't really important - what's important is that the two programs
being piped are separate works.  Copyright law doesn't care about how two
separate works communicate.  It only covers distribution and any use that
is not "fair use".

> Also, there is no advertised interface for piping. (a pipe is just a
> byte stream).

That doesn't really matter either - it's not the interface being
advertised that creates the problem, but rather the inclusion of headers
which are covered under copyright.  If the interface was described in a
white paper, without code being distributed, or if the headers were public
domain, this would not cause a problem.

> However, note that the output of a program is usually subject to
> copyright law, so a pipe is legal if the license for the output allows
> usage of it. The GPL explicitely does not restrict usage.

Only if the output of the program is considered a derived work.  For
example, a program that prints its source code would have its output
covered by copyright.  But a program that outputs arbitrary data does
*not* place its output under the copyright of the original program.  If
you use a program to create a separate work, you own the copyright to it.
If you use a word processor, documents you write with it are yours; if you
use a compiler, copyright on the executable belongs to the owner of the
source code, and if you use Acrobat Reader to print a PDF, then the
copyright on the results belong to the owner of the PDF, not to Adobe.

> explicitely allow it. Piping is restricted, but allowed as "use" by
> all free software licenses (if you don't bundle the application and

And by copyright law in general, as fair use.

> distribute them as a whole). Calling kernel functions is restricted,
> but allowed by the linux kernel license (or the other way round, by
> the GPL in the exception clause).

Mostly this is a result of having to include some portion of the kernel or
library in the program that wants to include it, as headers.  This makes a
derived work.  Using a pipe does not create a derived work since the two
programs are separate even while the pipe is being used.

Reply to: