question about bsd-style license requirements - accidental recipr ocity?

[Michael Sparks]

On Mon, 18 Oct 2004 Chad.Woodford at windriver.com wrote:
> I understand that this list is primarily devoted to discussing open
> source license approval.

I'm not convinced that asking how to turn open source code to "proprietary
source" is particularly on topic, or morally acceptable, but the
accidental reciprocity clause is interesting. Simple answer is "don't do
that" if you don't want to hit a clause in a license. My answer here is
based on the basis that I prefer to release code under the BSD license, so
I thought it might be helpful to you.

The other short answer is the license only covers the portions of code you
include, and if you make *that* clear and *which* bits, then you can
license *your* bits under any license *you* choose. Making this manageable
is discussed below.

> I am dealing with an issue involving a license in every way similar to
> the most recent BSD/academic-style license.  I.e.,
> http://www.opensource.org/licenses/bsd-license.php.  Basically, we would
> like to take smaller groupings of lines of code--snippets, if you will--from
> a piece of software licensed under that license and incorporate them into
> proprietary code, which is released under a proprietary source code license.
> I'm curious about the logistics of doing this.

The traditional route for taking BSD code and including it into a
proprietary work is to follow the BSD license stipulations. It doesn't
create a copyleft scenario. Indeed the absence of a copyleft provision is
one of the key differences in many people's eyes between (say) the BSD and
GPL licenses.

What does this mean? It means that should *YOU* choose to redistribute the
original BSD licensed material in source or binary form you have to adhere
to the restrictions.
   * For example, should you wish to redistribute in binary form ONLY,
     then the first bullet doesn't apply - you're not redistributing
     source.
   * If you're ONLY redistributing source, then you're not redistributing
     binaries, which means the second bullet doesn't apply.

If you're redistributing binaries AND source, there is no requirement in
the license that states that the binaries must be built from the sources
you provide.

Probably one of the best examples to look at with regard to "adding value"
to BSD code and releasing only binaries is Mac OS X, which is largely
based (AIUI, BICBW) FreeBSD (might be another BSD). They don't release the
sources to their changes.

Essentially the BSD license requires you to acknowledge where you got help
from and not a lot else in the case of binary redistribution.

This model has allowed (among MANY others) Microsoft and Apple to take BSD
licensed code, "add value" and release without source. They do have to
have copyright notices in appropriate places, but that shouldn't be a big
deal.

In your case you're talking about a proprietary SOURCE release, but even
so, similar _principles_ can apply. Since you don't own the original code,
you don't have the right to relicense the code under different conditions
without the agreement of the license holder. (You could always ask them
and see if they're willing to do so, either for free or money. They
*might* agree)

> Here is what I am thinking:  The academic-style license can be broken down
> into three or four parts, depending on whether you include the copyright
> notice.  The three basic parts are the rights-granting part, the list of
> conditions, and the disclaimers.

> Where you are copying or modifying the
> code, condition #1 requires you to reproduce the copyright notice and the
> list of conditions (and the disclaimers).

No, it states that *redistributions* of the source code must do that. If
you're not redistributing their source, you don't hit that clause. (Even
then, the clause ONLY applies to *their* source.)

If you are, you are. And if you are you're bound by the license they
chose. You might not like their license but you are bound by it, and
cannot arbitrarily change the license on that source.

Since you wish redistribute source in proprietary form and you don't wish
to license *your* code under the same BSD license, you need to ensure that
the two sets of licenses are kept separate, to minimise confusion. The
simplest way of doing this is by keeping things is separate files. Your
code avoids any ambiguity.

You could add a "portions of this file" notice, or put delimiters in the
file around the portions covered by that license, but it's far more
sensible to separate things into different files. The clearer you make
the division the less likelyhood of arguments down the line.

> So does that mean that you can omit what I am calling the
> rights-granting part when you copy the code into a larger proprietary
> work?

You're under no obligation to redistribute source from others. If you do,
then since you don't own the copyrights on that original code, you can't
strip out the copyright notices or terms and conditions. If you don't want
to pass on those abilities, don't redistribute source.

It's fairly cut and dried really.

> Because if you don't then it seems that the
> license would create at least an apparent reciprocity obligation for the
> particular file it is copied into.  I mean to the uninformed observer, that
> pesky rights-granting part would appear to apply to the entire source code
> file.

If you're truly worried about that, why not put the code into a seperate
file ? That way the licensing is completely clear for people. I mean if
you're having problems with this, then recipients of your code will have
the same problem. Why not make everyone's lives easier (yours especially)
and do that?

Incidentally that "pesky rights-granting part" is in many free software or
open source developer's perspective *the most important part*. Your
phrasing isn't the most diplomatic you could use here :-)

> The reason I'm asking is that, although omitting the rights-granting part
> seems to make sense, I have never seen this done.

It wouldn't be open source, which is probably why - so whilst it makes
sense to you, it doesn't to anyone interested in releasing their work as
open source.

If you REMOVE ...
   "Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:"

... from http://www.opensource.org/licenses/bsd-license.php then there is
no  words in that license that allow you to redistribute/etc. For example
stepping through the modified version with that sentance removed:

   * "Redistributions of source code ..."

This becomes irrelevant, because you would be infringing copyright because
you haven't been granted the rights involved.

   * "Redistributions in binary form ..."

Ditto, for the same reasons.

   * "Neither the name of the <ORGANIZATION> nor ..."

This doesn't grant redistributon/etc

   * "THIS SOFTWARE IS PROVIDED"

This doesn't grant redistributon/etc.

> Nor have I seen this
> approach discussed anywhere (including Mr. Rosen's wonderful OSS book).
> Perhaps this is because it is legally acceptable to take this approach but,
> within the OSS community, morally unacceptable?

I'm not going to cover whether it's morally unacceptable or not, but I
would say it's impractical, and the result wouldn't be free software (and
hence morally unacceptable to that crowd) and wouldn't be open source
(doesn't allow allow redistribution/modification). As a result you
wouldn't see it being used by the open source or free software crowds,
since it would be neither.

> I suppose an alternative approach for the above scenario would be to insert
> additional verbiage above the license text which says that some of the
> source code in the file is licensed under the academic license and some is
> licensed under the proprietary source code license.  But that is a bit
> messier; not quite as elegant.

I'd suggest just keeping code in separate files. You can then note in the
general copyright notice for your application that files X,Y,Z are covered
by a BSD license.

After all you don't own the intellectual monopoly rights on that software,
you received it for free, and the least you can do is respect the wishes
of the developer who gave it to you.

FWIW, I tend to use the BSD license for code I personally release, so my
comments are based on the behaviour I would expect you to follow. I'm not
a lawyer, but they're also based on my understanding of the legal aspect,
which may be flawed. (I'm trying not be flawed, but it may well be because
I'm not a lawyer :)

I've tried to keep my personal feelings out of this. FWIW, I hate what
you're asking to do since you're distorting the BSD license into it's
complete opposite simply because you don't want to do something that
someone who's help you want to accept expects you to do.

Best Regards,


Michael.
--
I am not a Lawyer, This isn't legal advice, and if you treat as such you
only have yourself to blame if things go wrong :-)