Do I need to license my code as GPLv2 if I only read/write to a database and pipe?

Question

I'm writing an API for an open source network monitoring system which is licensed under the GPLv2. I also intend to open source this API but would like to license it under the BSD License.

• I don't re-use or link to any of the code in this system and I don't use any header files.
• I will not be re-distributing any part of the network monitoring code.
• Part of my application will install into the network monitoring installation folders, but not replace, remove or modify any of its files

My hook into the system is via:

• existing MySQL databases belonging to the service, my API reads and writes to these databases directly. My concern here would be that whilst I am not copying their SQL statements, there are some complex operations. I've found that in a couple of cases I've arrived at SQL statements or sequences of work that aren't too dissimilar to theirs, it's hard not to.

• I talk to a pipe to issue various commands and submit data directly into the checking engine. This pipe is documented by the author as an official mechanism to communicate with the checking engine. The command pipe uses single line strings to issue commands, the pipe does not return any data, it's "fire and forget".

• There are a number of HTTP CGI scripts in the system from which I can scrape status information. I may use these in a future release.

Is this considered "arms length" enough for me to license my code under a different license? i.e.

http://www.gnu.org/licenses/gpl-faq.html#MereAggregation

However, in many cases you can distribute the GPL-covered software alongside your proprietary system. To do this validly, you must make sure that the free and non-free programs communicate at arms length, that they are not combined in a way that would make them effectively a single program.

Would reading and writing rows to a database be considered "exchanging complex internal data structures"?

http://www.gnu.org/licenses/gpl-faq.html#MereAggregation

By contrast, pipes, sockets and command-line arguments are communication mechanisms normally used between two separate programs. So when they are used for communication, the modules normally are separate programs. But if the semantics of the communication are intimate enough, exchanging complex internal data structures, that too could be a basis to consider the two parts as combined into a larger program.

Answer 1

You shouldn't be checking the GPL FAQ for this information. These are questions about the scope of the license, and the license cannot set its own scope. (And the FSF is not a party to the license, so they can't even waive rights the author might have.)

What matters is whether your work is a derivative work under copyright law. That is determined based on whether or not your work contains sufficient protectable expression taken from the work covered by the GPL.

First, the easy case, the database. You are not exchanging internal structures with the database. You are issuing commands to the database, and it is returning your data to you. In any event, the structure comes from the SQL standard, so I don't see how it could be protected expression from MySQL.

The pipe case is more complex. But if it's basically external structures (commands, responses), you should be okay. This is especially true if it's a documented interface. Functional elements cannot be protected by copyright, and as a general rule, if you take only what you need to interoperate, you are only taking functional elements. (But be careful with things like header files, because these contain parameter names and macros which one can argue you don't need to interoperate.)

Obviously, you should ideally consult a lawyer.

Answer 2

I don't re-use or link to any of the code in this system and I don't use any header files.

If that is the case, then the GPL would consider your program to operate with the network monitoring system via "pure aggregation", which does not require your code to be placed under the GPL.

David Schwarz's answer also has a very good point in that your code would likely not be considered a derivative work under copyright law, making the network monitor's licensing terms irrelevant in any case, unless they included an (enforceable) EULA specifically stating that you may not access or use its stored data in the way that your program does.

Standard disclaimer: IANAL, just a programmer who's read way too much about this stuff for his own good. Consult a lawyer licensed to practice in your jurisdiction if you need a definitive answer.

Answer 3

It looks like you can use a BSD license as you are just using the GPLed system and not modifying the source of that system.

Why you would want to use the BSD license at all is another matter. The BSD license is equivalent to no license at all. If you distribute your code under BSD, and, it looks like a good product I can, under the terms of the BSD license, take your code, shrink wrap it and sell it as my own without consulting you or giving you any share of the profits. I can even make some minor changes to the code and sell it under a proprietary license.

If you don't believe me take a look at the license for MAC/OS. Considering that 90% of the code is BSD Unix their are some pretty Draconian terms in there.

Answer 4

Check with a lawyer.

Your description does show a system which can be licensed independently of the original system. That said, check with a lawyer to be sure, since things change depending on your jurisdiction.

In practical terms, though, since you're not selling your API, you're not at great risk of being sued or otherwise getting into trouble. If you end up having to change licenses farther down the road, that's probably ok.

However, we're not lawyers. If this is really a source of concern for you, then check with a lawyer.