Es schrieb Michel Bardiaux:
Andy Gordon wrote:
[snip]
Correct me if I’m wrong, but I was under the impression that you didn’t
have to give the source code WITH the product, but that you had to make
it obviously available if wanted…
With GPL yes, with LGPL no. The idea behind LGPL is that you can link
a proprietary product to the LGPL library, but people do not have to get
the library from you (cuz then it would be effectively proprietary).
Which forces you to dynamically link to the library.
Almost … actually, you can ship your (proprietary) program with a
modified version (!!) of an LGPL’ed library - in that case, you must
publish the sources of the modified library. However, most libraries
are already in a state that suffices the requirements of the program,
so you can just dynalink with the standard library, and in that case,
the complete sources to the library have been published already, in
their standard place. The same applies to GPL libraries btw, you can
even ship your program with a modified version, and in that case you
must publish the modified library code, and again, for the standard
GPL code, you don’t need to ship it if there is a standard place for
it. Anyway, if you dynalink with a LGPL, you are on good legal ground
that you don’t need to publish the sources to your program, while
with the GPL, this is not usually the case - even that there are cases
where you can link GPL code to non-GPL stuff. The conditions are
based on a fuzzy thing called “mere use”, and that the GPL code is
"independent" of that other code, or “at arm’s length” as it was
expressed in the GPL FAQ. That’s certainly a good ground for lawyers
to discuss before court - with the LGPL you are on the safe side,
since it boils down to one condition - keep your propriatary code
and the opensource code in different files, and bind them only at
startup with the dynaloader. Basically, you could fetch some LGPL’ed
library, modify it by placing some extra hooks into it, so that
it would only correctly work when linked to some other code, being
possibly propriatary. That’s the danger in there that the copyright
holder of the LGPL’ed library has to accept, and it is probably
the reason why RMS argues that the strict GPL is a better protection
for library code too. In essence, the GPL cares about “use” and
protects from “abuse” by non-opensource enterprises, the LGPL does
not care, but it protects the code from becoming non-free - each
modification to the library must be published and it is therefore
ready to be merged back. The “customer” (of a proprietary program
dynalinked with it) has the chance to modify the modifed code, and
enhance it with the latest patches from the standard version, or look
at the modifications for a greater value so that it can be merged back
into the standard version. In most cases, the original “vendor” will
have done that anyway, since there is no use to wait for it to be done
by a third person. And therefore, one can expect that there are more
code contributions to LGPL’ed code than there are for GPL’ed ones,
since commercial entities are much easier to pick up this code (on
on hand), and since the license enforced it, they send patches back
(on the other hand), where weaker opensources licenses must refer
to good will. I see the LGPL as a good mixture, as it will ensure
the library by itself to remain free, and one can use it in
most paid jobs - I don’t know why I would need to look at the API
of GPL’ed libraries since I could only pick it in one part of my
life, which is not that one which is paying my daily expenses.
but, let’s come back to the original question:
But before getting into it, I wonder if this is ‘legal’ to do, since I
will
not be able to release the source codes of the modified version. But
anyways, it will not have any benefit compared to the current version, it
will just run under a different engine, using different Surface structures
mainly. So actually there is not even a single worthy thing I could donate
back to the public.
This is illegal. Well, unlike GPL, you are allowed to link with proprietary
code, and a different engine. Since that other engine isn’t public,
it is as you state later - it wouldn’t give much benefit for the original
opensource part AS IT IS TODAY, but it will still give an opportunity
to the USERS that will use your modified version, to simply modify it again.
And these users may contribute later on, ye know. And since it is a
modified version, you can not just dynalink with it and make a hint to
the non-modified version as this is prohibited by the license.
However, there are atleast two paths for you out of this complication:
a) make an agreement with the original copyright holder - you stated
that it is basically to strip down the code, and you would be willing
to give credit atleast. Anyway, the original copyright holder may
accept that, or he may accept that if you pay a certain fee, that
your employer might be willing to consider in return for picking this
fine piece of code. And yes, the original copyright holder is
allowed to make an extra non-opensource license agreement with you.
And no, the mere inclusion of patches sent to the original copyright
holder does not make the submitters to become copyright holders too,
they must request so, or their piece must be of such great quality
that it is beyond a simple patch but a kind of feature of its own.
Therefore, only those marked as copyright holders in the
documentation of the libary are the ones to talk to, and no, the
smpeg was not submitted to the FSF like other GNU code, so those
could veto into an extra license agreement with you. You can
get an extra license, possibly paid for.
b) the other path is derived from the section above - you are fine
with putting in function hooks, and to use different data
structures with it from different headers - as long as you ship
those header files too, along with the mofied source code. You
can use this as a backdoor with putting only function calls in
there whose call entries are resolved in a different closed-source
library that your modified-smpeg.dll must be linked with to
function correctly. Now, all you need is to publish the sources
of your stripped-down full-of-hooks code, so either ship it on CD
to your customer, or place it on the website where you probably
advertise your product too as soon as it ships. (well, I would
not like to maintain such full-of-hooks beast).
Well, part (b) is quite an effort, and since the existance of (b) is
known, you can be sure that (a) won’t cost your employer that much
money that you couldn’t afford it. So I recommend to choose (a) and
write to the copyright holders of smpeg today. And since it is as
you say, that you just strip it down, he may just give it for free
in return for an advertiser on your product box, ye know. But you
have to contact them, don’t do it just so, without asking for
an explicit permission.
cheers,
– guido http://freespace.sf.net/guidod
GCS/E/S/P C++/++++$ ULHS L++w- N++@ d(±) s+a- r+@>+++ y++ 5++X- (geekcode)