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


<h3>Hall of Shame!!!</h3>

<p>This page is no longer updated, these days we forward this sort of
thing to the <a href="http://www.softwarefreedom.org">Software Freedom Law
Center</a> instead.</p>

<p>The following products and/or projects appear to use BusyBox, but do not
appear to release source code as required by the <a
href="/license.html">BusyBox license</a>.  This is a violation of the law!
The distributors of these products are invited to contact <a href=
"mailto:andersen@codepoet.org">Erik Andersen</a> if they have any confusion
as to what is needed to bring their products into compliance, or if they have
already brought their product into compliance and wish to be removed from the
Hall of Shame.

<p>

Here are the details of <a href="/license.html">exactly how to comply
with the BusyBox license</a>, so there should be no question as to
exactly what is expected.
Complying with the Busybox license is easy and completely free, so the
companies listed below should be ashamed of themselves.  Furthermore, each
product listed here is subject to being legally ordered to cease and desist
distribution for violation of copyright law, and the distributor of each
product is subject to being sued for statutory copyright infringement damages
of up to $150,000 per work plus legal fees.  Nobody wants to be sued, and <a
href="mailto:andersen@codepoet.org">Erik</a> certainly would prefer to spend
his time doing better things than sue people.  But he will sue if forced to
do so to maintain compliance.

<p>

Do everyone a favor and don't break the law -- if you use busybox, comply with
the busybox license by releasing the source code with your product.

<p>

<ul>

  <li><a href="http://www.trittontechnologies.com/products.html">Tritton Technologies NAS120</a>
	<br>see <a href="http://www.ussg.iu.edu/hypermail/linux/kernel/0404.0/1611.html">here for details</a>
  <li><a href="http://www.macsense.com/product/homepod/">Macsense HomePod</a>
	<br>with details
	<a href="http://developer.gloolabs.com/modules.php?op=modload&amp;name=Forums&amp;file=viewtopic&amp;topic=123&amp;forum=7">here</a>
  <li><a href="http://www.cpx.com/products.asp?c=Wireless+Products">Compex Wireless Products</a>
    <br>appears to be running v0.60.5 with Linux version 2.4.20-uc0 on ColdFire,
    but no source code is mentioned or offered.
  <li><a href="http://www.inventel.com/en/product/datasheet/10/">Inventel DW 200 wireless/ADSL router</a>
  <li><a href="http://www.sweex.com/product.asp">Sweex DSL router</a>
    <br>appears to be running BusyBox v1.00-pre2 and udhcpd, but no source
	code is mentioned or offered.
  <li><a href="http://www.trendware.com/products/TEW-410APB.htm">TRENDnet TEW-410APB</a>
  </li><li><a href="http://www.hauppauge.com/Pages/products/data_mediamvp.html">Hauppauge Media MVP</a>
  <br>Hauppauge contacted me on 16 Dec 2003, and claims to be working on resolving this problem.
  </li><li><a href="http://www.hitex.com/download/adescom/data/">TriCore</a>
  </li><li><a href="http://www.allnet.de/">ALLNET 0186 wireless router</a>
  </li><li><a href="http://www.dmmtv.com/">Dreambox DM7000S DVB Satellite Receiver</a>
  <br> Dream Multimedia contacted me on 22 Dec 2003 and is working on resolving this problem.
  <br> Source _may_ be here: http://cvs.tuxbox.org/cgi-bin/viewcvs.cgi/tuxbox/cdk/
  </li><li><a href="http://testing.lkml.org/slashdot.php?mid=331690">Sigma Designs EM8500 based DVD players</a>
  <br>Source for the Sigma Designs reference platform is found here<br>
    <a href="http://www.uclinux.org/pub/uClinux/ports/arm/EM8500/uClinux-2.4-sigma.tar.gz">uClinux-2.4-sigma.tar.gz</a>, so while Sigma Designs itself appears to be in compliance, as far as I can tell,
    no vendors of Sigma Designs EM8500 based devices actually comply with the GPL....
  </li><li><a href="http://testing.lkml.org/slashdot.php?mid=433790">Liteon LVD2001 DVD player using the Sigma Designs EM8500</a>
  </li><li><a href="http://www.rimax.net/">Rimax DVD players using the Sigma Designs EM8500</a>
  </li><li><a href="http://www.vinc.us/">Bravo DVD players using the Sigma Designs EM8500</a>
  </li><li><a href="http://www.hb-direct.com/">H&amp;B DX3110 Divx player based on Sigma Designs EM8500</a>
  </li><li><a href="http://www.recospa.it/mdpro1/index.php">United *DVX4066 mpeg4 capable DVD players</a>
  </li><li><a href="http://www.a-link.com/RR64AP.html">Avaks alink Roadrunner 64</a>
  <br> Partial source available, based on source distributed under NDA from <a href="http://www.lsilogic.com/products/dsl_platform_solutions/hb_linuxr2_2.html"> LSILogic</a>. Why the NDA LSILogic, what are you hiding ?
  <br>To verify the Avaks infrigment see my slashdot <a href="http://slashdot.org/~bug1/journal/">journal</a>.
  <br>The ZipIt wireless IM device appears to be using Busybox-1.00-pre1 in the ramdisk, however no source has been made available.
  </li><li>Undoubtedly there are others...  Please report them so we can shame them (or if necessary sue them) into compliance.

</ul>


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

