If the main program dynamically links plug-ins, and they make function calls to each other and share data structures, we believe they form a single combined program, which must be treated as an extension of both the main program and the plug-ins. If the main program dynamically links plug-ins, but the communication between them is limited to invoking the ‘main’ function of the plug-in with some options and waiting for it to return, that is a borderline case.

The Fig.1 apparently ruled out (not sure about Fig.2 completely though), however, where does make function calls to each other and share data structures part ends anyway?

(Q-1) Is Fig.2 the same as Fig.1 in this respect after all?

(Q-2) Is IPC/shared memory page to purely exchange data counts? It lacks one of function calls AND share data structures, only sharing data structures that may themselves be under LGPL, dual-licensed or public domain.

(Q-3) Is network-based RPC falls into same category as shared memory? What if RPC implementation (e.g. zeromq) can be configured to use shared memory as a transport as well as some TCP/UDP/Unix socket?

1 Answer
1

Yes. There is no significant difference between Fig.2 and Fig.1 with regards to determining if they are considered a single combined program or not.

(Q-2) Is IPC/shared memory page to purely exchange data counts? It lacks one of function calls AND share data structures, only sharing data structures that may themselves be under LGPL, dual-licensed or public domain.

This depends on the data structures that are being shared and the kind of calls made over the IPC connection. GPL code can interact with proprietary code if this interaction happens "at arm's length". This effectively means that the side that falls under the GPL regime can be written without having knowledge of how the proprietary code is implemented and that it is possible to replace the proprietary code with an open-source alternative (where the feasibility of writing the alternative is not considered).

(Q-3) Is network-based RPC falls into same category as shared memory? What if RPC implementation (e.g. zeromq) can be configured to use shared memory as a transport as well as some TCP/UDP/Unix socket?

Network based communications fall in the same category as the on-machine IPC/shared memory. With network based communications, it is usually easier to keep the two parts "at arm's length," because the network protocols make it harder to accidentally share implementation details.

So having some RPC definition with LGPL/PublicDomain/Dual-Licensed generated structures should do, as anyone could take same RPC definition and provide FOSS implementation doing same thing, effectively satsifying both interface contract and GPL requirements, even if some proprietary implementations doing that too are around. Thanks.
– Alexander TuminJul 9 at 13:56