<!--#include file="header.html" -->


<h3>The GPL BusyBox license</h3>

There has been some confusion in the past as to exactly what is
required to safely distribute GPL'd software such as BusyBox as
part of a product.  To ensure that there is no confusion
whatsoever, this page attempts to summarize what you should do to
ensure you do not accidentally violate the law.

<p>
<h3>Complying with the BusyBox license is easy and completely free.</h3>

U.S. and International Law protects copyright owners from the unauthorized
reproduction, adaptation, display, distribution, etc of copyright protected
works.  Copyright violations (such as shipping BusyBox in a manner contrary to
its license) are subject to severe penalties.  The courts can award up to
$150,000 per product shipped without even showing any actual loss by the
copyright holder.  Criminal penalties are available for intentional acts
undertaken for purposes of "commercial advantage" or "private financial gain."
In addition, if it comes to my attention that you are violating the BusyBox
license, I will list you on the <a href="/shame.html">BusyBox Hall of Shame</a>
webpage.

<p>

Nobody wants that to happen.  Do everyone a favor and don't break the law -- if
you use BusyBox, you <b>must comply with the BusyBox license</b>.

<p>
<h3>BusyBox is licensed under the GNU General Public License</h3>

BusyBox is licensed under the GNU General Public License , which
is generally just abbreviated as the GPL license, or
just the GPL.
<p>
<a href="/products.html">Anyone thinking of shipping
BusyBox as part of a product</a> should be familiar with the
licensing terms under which they are allowed to use and
distribute BusyBox.  You are advised to take a look over the

<ul>
<li><a href="http://www.gnu.org/licenses/gpl.html">full text of
the GNU General Public License</a>, and
<li><a href="http://www.gnu.org/licenses/gpl-faq.html">
Frequently Asked Questions about the GNU GPL</a>
</ul>
to be sure you (and your lawyers) fully understand them.

<p>

The following is a quick summary for the impatient.  If you
carefully follow these steps, it will ensure that you are 100%
authorized to ship BusyBox with your product, and have no reason
to worry about lawsuits or being listed on the <a
href="/shame.html">BusyBox Hall of Shame</a> page.  You will be
able to sleep peacefully at night knowing you have fulfilled all
your licensing obligations.

<p>

If you distribute a product, it should either be accompanied by
<b>full source for all GPL'd products</b> (including BusyBox)
and/or a <b>written offer</b> to supply the source for all
GPL'd products for the cost of shipping and handling.  The source
has to be in its preferred machine readable form, so you cannot
encrypt or obfuscate it.  You are not required to provide full
source for all the closed source applications that happen to be
part of the system with BusyBox, though you can certainly do so
if you feel like it.  But providing source for the GPL licensed
applications such as BusyBox is mandatory.

<p>

<b>Accompanied by source</b> generally means you distribute the full
source code for all GPL'd products including BusyBox along with your
product, such as by placing it somewhere on a driver CD.  Full source
code includes the BusyBox ".config" file used when your shipping BusyBox
binary was compiled, and any and all modifications you made to the
BusyBox source code.

<p>

<b>A written offer</b> generally means that somewhere in the
documentation for your product, you write something like

<blockquote>
The GPL source code contained in this product is available as a
free download from http://blah.blah.blah/
</blockquote>
Alternatively, you can offer the source code by writing
somewhere in the documentation for your product something like
<blockquote>
If you would like a copy of the GPL source code contained in this
product shipped to you on CD, please send $9.99 to &lt;address&gt;
which covers the cost of preparing and mailing a CD to you.
</blockquote>
<p>

Keep in mind though that if you distribute GPL'd binaries online (as is often
done when supplying firmware updates), it is <b>highly</b> recommended that you
make the corresponding source available online at the same place.  Regardless,
if you distribute a binary copy of BusyBox online (such as part of a firmware
update) you <b>must</b> either make source available online (i.e.
<b>accompanied by source</b>) and/or inform those downloading firmware updates
of their right to obtain source (i.e. <b>a written offer</b>).  Failure to do
so is a violation of your licensing obligations.


<p>

Some people have the mistaken understanding that if they use unmodified
GPL'd source code, they do not need to distribute anything.  This belief
is not correct, and is not supported by the
<a href="http://www.gnu.org/licenses/gpl.html">text of GPL</a>.
Please do re-read it -- you will find there is no such provision.
If you distribute any GPL'd binaries, you must also make source available
as discussed on this webpage.

<p>
<h3>A Good Example</h3>

These days, <a href="http://www.linksys.com/">Linksys</a> is
doing a good job at complying with the GPL, they get to be an
example of how to do things right.  Please take a moment and
check out what they do with
<a href="http://www.linksys.com/download/firmware.asp?fwid=178">
distributing the firmware for their WRT54G Router.</a>
Following their example would be a fine way to ensure that you
have also fulfilled your licensing obligations.


<!--#include file="footer.html" -->

