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


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

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>. 
  </li><li><a href="http://www.zyxel.com/">ZyXEL Routers</a>
  <br>At least the Prestige 330W is in violation, see <a href="http://bugs.uclibc.org/view.php?id=355">the bug tracker</a> for more info.
  </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" -->

