kytv/I2P_Website
1
0
Fork 0
forked from I2P_Developers/i2p.www
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved the last few unsorted pages into misc/ (and ports into docs/)

Browse Source
This commit is contained in:
str4d
2012-12-19 01:47:48 +00:00
parent 32db04d701
commit 914492e625
6 changed files with 14 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
i2p2www/pages/site/docs/ports.html Normal file
View File

@@ -0,0 +1,66 @@
{% extends "global/layout.html" %}
{% block title %}Ports Used by I2P{% endblock %}
{% block lastupdated %}May 2012{% endblock %}
{% block accuratefor %}0.9{% endblock %}
{% block content %}
<p>
These are the ports used or reserved by I2P, including those for known plugins,
common alternates,
and some typical related applications.
<p>
Note that many of these are not enabled by default.
There is more information in <a href="{{ site_url('support/faq') }}#ports">the FAQ</a>.
See also the documentation for individual plugins.
Plugin authors please add any ports you use here.
For new plugins, we recommend using the next available port
in the 766x range.
<table>
<tr><th>Port</th><th>Usage</th></tr>
<tr><td>123</td><td>SNTP</td></tr>
<tr><td>1900</td><td>UPnP SSDP UDP multicast listener</td>
<tr><td>2827</td><td>BOB Bridge</td></tr>
<tr><td>3456</td><td>Tahoe-LAFS-Controller Plugin</td></tr>
<tr><td>3458</td><td>Tahoe-LAFS-Controller Plugin</td></tr>
<tr><td>3459</td><td>Tahoe-LAFS-Controller Plugin</td></tr>
<tr><td>4444</td><td>HTTP Proxy</td></tr>
<tr><td>4445</td><td>HTTPS Proxy</td></tr>
<tr><td>4691</td><td>Monotone Server (reserve)</td></tr>
<tr><td>6667</td><td>IRC Proxy (alt)</td></tr>
<tr><td>6668</td><td>IRC Proxy</td></tr>
<tr><td>6669</td><td>IRC Proxy (alt)</td></tr>
<tr><td>7650</td><td>I2PControl Plugin</td></tr>
<tr><td>7651</td><td>UPnP (alt - retries going down)</td></tr>
<tr><td>7652</td><td>UPnP HTTP TCP event listener</td></tr>
<tr><td>7653</td><td>UPnP SSDP UDP search response listener</td></tr>
<tr><td>7654</td><td>I2CP</td></tr>
<tr><td>7655</td><td>SAM Bridge (UDP)</td></tr>
<tr><td>7656</td><td>SAM Bridge (TCP)</td></tr>
<tr><td>7657</td><td>Router Console</td></tr>
<tr><td>7658</td><td>Eepsite</td></tr>
<tr><td>7659</td><td>SMTP Proxy</td></tr>
<tr><td>7660</td><td>POP Proxy</td></tr>
<tr><td>7661</td><td>Pebble Plugin</td></tr>
<tr><td>7662</td><td>Zzzot Plugin</td></tr>
<tr><td>7663</td><td>?? Plugin ??</td></tr>
<tr><td>7664</td><td>JAMWiki Plugin</td></tr>
<tr><td></td><td><i>recommended spot for new plugins/applications</i></td></tr>
<tr><td>8118</td><td>Privoxy (reserve)</td></tr>
<tr><td>8123</td><td>Tor Polipo (reserve)</td></tr>
<tr><td>8887</td><td>Old default network port</td></tr>
<tr><td>8997</td><td>Monotone Proxy (alt)</td></tr>
<tr><td>8998</td><td>Monotone Proxy</td></tr>
<tr><td>8999</td><td>Monotone Proxy (alt)</td></tr>
<tr><td>9050</td><td>Tor SOCKS Proxy (reserve)</td></tr>
<tr><td>9051-9053</td><td>SOCKS Proxy (typ)</td></tr>
<tr><td>9111-30777</td><td>Network (random)</td></tr>
<tr><td>31000</td><td>Wrapper</td></tr>
<tr><td>31001-31999</td><td>Wrapper (alt - retries going up)</td>
<tr><td>32000</td><td>Wrapper</td></tr>
<tr><td>65534</td><td>Neodatis Plugin</td></tr>
</table>
{% endblock %}

109
i2p2www/pages/site/misc/i2ptunnel_services.html Normal file
View File

@@ -0,0 +1,109 @@
{% extends "global/layout.html" %}
{% block title %}i2ptunnel services{% endblock %}
{% block content %}Below is quick copy of aum's eepsite deployment guide.
<br />
<br />
<strong>1. - Deploy a local server</strong><ul><li>For simplicity's sake, we will walk through the setup of a web server; however, this procedure is the same regardless what protocol of servers and/or clients you are setting up.
<br />
<li>I recommend the Tiny Httpd web server , thttpd, (windows version available on site) although you can use anything that you feel comfortable with.
<br />
<li>Another more robust option would be to use EasyPHP, which is also open source. It comes with PHP, PHPmyadmin, mySQL, and Apache web server. For newbies who have no experience setting up and hosting content over servers, see the hosting page for help.
<br />
<li>With the web server you've chosen, configure it to listen on a port of your choice, and serve its documents from a directory of your choice. For this example, we'll assume port 10880.
<br />
<li>Make sure your firewall is set up so that you cannot receive incoming connections on this port (which would breach your anonymity).
<br />
<li>Test the webserver, by pointing your normal browser (the one with the "direct connection") at <a href="http://localhost:10880" target="_blank">http://localhost:10880</a> (changing the 10880 to the port number you have chosen).
<br />
<li>Once your webserver is working, and you can access it locally with your browser, continue to the next step.
<br />
</ul><strong>2 - Generate an I2P Destination Keypair</strong><ul><li>I2P does not deal in IP addresses. To protect your anonymity, it deals in unique addresses called destination keys.
<br />
<li>A destination key works a lot like a regular IP address, except that it can't be traced to your IP address or physical location. When users place a request to speak with you, your gateways are the ones that answer for you. So the requesting user can only know the IP address of your gateways. However, gateways don't know your IP address, because gateways are the last nodes on your tunnels, and you anonymously create tunnels by way of garlic routing. (So gateways are like puppets that can't see their masters, and everyone communicates through these puppets)
<br />
<li>To deploy a server on I2P, you create a destination keypair. You use the private key to authenticate your server when connecting it to I2P, and you make the public key (aka destination key) known publicly, so others can connect to your server. (indirectly, through your gateways)
<br />
<li>Each service you run on I2P requires a different keypair.
<br />
<li>To generate your keypair, type the command: java -jar lib/i2ptunnel.jar -nogui -e "genkeys myWebPrivKey.dat myWebPubKey.dat" (all on one line)
<br />
<li>In windows, to generate your keypair, type the command: java -jar lib/i2ptunnel.jar -nogui -e "genkeys myWebPrivKey.dat myWebPubKey.dat"
<br />
<li>The filenames myWebPrivKey.dat and myWebPubKey.dat are arbitrary - choose whatever you want here, as long as you understand your own choices.
<br />
<li>We now need to export your public key into base64 format, which you will share with others.
<br />
<li>To convert your myWebPubKey.dat file into shareable base64, type the command java -cp lib/i2p.jar net.i2p.data.Base64 encode myWebPubKey.dat &gt; myWebPubKey.txt (all on one line).
<br />
<li>This file you have just generated, myWebPubKey.txt, contains a long base64 string (516 chars at last count), which we call a destination key. All you need to know about this string for now is that it allows remote clients to uniquely pinpoint and connect to your server, just the same way as an IP address allows remote machines to pinpoint and connect to your machine.
<br />
<li>However, in contrast to an IP address, there is no way to trace your machine's physical location - even though your server can be addressed via I2P, your IP address cannot be traced or associated with this destination key.
<br />
</ul><strong>3 - Open a 'Tunnel' from I2P To Your Server</strong><ul><li>For clients elsewhere in I2P to be able to access your server, you must run a 'bridge' or 'tunnel', which takes connections from these clients and forwards them to your local server
<br />
<li>To activate such a tunnel, type the command java -jar lib/i2ptunnel.jar -nogui -e "server localhost 10880 myWebPrivKey.dat" (all one line)
<br />
<li>If you used different filenames or port number earlier on, change these accordingly
<br />
<li>Windows users, remember to replace apostrophes with double quotes. Thus: java -jar lib/i2ptunnel.jar -nogui -e "server localhost 10880 myWebPrivKey.dat"
<br />
<li>Within a few seconds, the 'tunnel' should now be active, and remote clients should be able to reach your server anonymously. Remember to let your router "warm up" before opening clients to it.
<br />
</ul><strong>4 - Update Your hosts.txt File</strong><ul><li>To test your own server locally, you'll need to create an entry in your hosts.txt file, so I2P can translate the simple URL you place in the browser's address bar into the full public key text needed to find your server.
<br />
<li>Edit your hosts.txt, and add the line myserver.i2p=blahblahblah, where myserver.i2p is an I2P 'domain' you want to associate with your site, and the blahblahblah is the text of the base64 public key you created earlier in the file myWebPubKey.txt
<br />
<li>With this in place, you and others can reach your server with the simple domain name myserver.i2p in the browser's address bar.
<br />
</ul><strong>5 - Surf Your Site Within I2P</strong><ul><li>Using your secondary browser - the one you earlier configured to use localhost:4444 as a proxy - point this browser to the address <a href="http://myserver.i2p" target="_blank">http://myserver.i2p</a>
<br />
<li>You should see the main page of your webserver come up.
<br />
</ul><strong>6 - Create a Local Client Tunnel Connection</strong><ul><li>We now have to think beyond just web servers.
<br />
<li>As you grow into I2P and get more of a 'feel' for it, you will want to use all manner of servers and clients.
<br />
<li>The beauty of I2P is that it allows standard Internet clients and servers for most protocols to be transparently 'tunneled' through the anonymous network.
<br />
<li>You can run mailservers/clients, nameservers/clients, newsservers/clients - almost anything at all - perhaps even FTP in passive mode.
<br />
<li>Now, we'll create a client tunnel. This is like the server tunnel we created earlier, but works in reverse. It listens to a port on your local machine; your local client connects to this port; the connection gets forwarded through I2P to the service on the other end.
<br />
<li>To open your client tunnel for your server, type the command java -jar lib/i2ptunnel.jar -nogui -e "config localhost 7654" -e "client 10888 textofbase64key" (all one line).
<br />
<li>The port 10888 is arbitrary - it just needs to be something other than the physical port your server is listening on.
<br />
<li>textofbase64key is simply the contents of the public key text file myWebPubKey.txt, reproduced fully on one line (alternately, instead of textofbase64key, you can specify the name from your hosts.txt - e.g. myserver.i2p)
<br />
<li>Within a minute or two of launching this command, the client tunnel from your local machine into I2P will be open and ready for use.
<br />
<li>Point your regular web browser (ie, not the one you configured to use localhost:4444), and point it to <a href="http://localhost:10888" target="_blank">http://localhost:10888</a>
<br />
<li>Verify that the main page of your server eventually comes up in your browser.
<br />
<li>You use the same procedure for using any local client program to access a remote I2P server - just get the base64 public key (called destination key) of the remote server, choose a local port to connect to the remote server, open the tunnel, and just connect with your client to your heart's content.
<br />
</ul><strong>7 - Share your server details with others</strong><ul><li>Using an anonymous medium (eg the one of the I2P IRC servers or ugha's wiki), post your domain name (eg <a href="http://www.mynick.i2p" target="_blank">www.mynick.i2p</a> as well as your destination key. Others will then be able to reach your server remotely, without either of you jeopardizing your anonymity.
<br />
<li>Remember, you can go to What's on I2P and find the latest public keys linked to their URL. You should also post your own public key and URL their. However, you will want to do this anonymously, of course. Drupal.i2p.net is currently, as of this writing, only accessible from the net. So, to access the outside WWW anonymously from inside of I2P, you will need to start up your script called startSquid. Do it the same way you have been doing these other scripts. Reconfigure your browser to proxy on localhost:5555, as defined in the script, and when the script has generated it's keys, you can access the squid proxy. Put any WWW URL (such as Google or this i2p site) into your browser's address bar and you will be surfing the World Wide Web anonymously. Now you can safely post your public key, and no one can detect your IP address.
<br />
</ul><strong>8 - Write Some Scripts To Handle All This Menial Nonsense</strong><ul><li>It would drive most people crazy, going through all these steps every time one sets up an I2P server, and/or deploys a client.
<br />
<li>Aum's website <a href="http://www.freenet.org.nz/i2p/" target="_blank">http://www.freenet.org.nz/i2p/</a> has a script called setupServer.py which automates all this nonsense into one simple command line . But I respect that people's tastes in user interfaces differ, and trying to write something which satisfies everyone's needs usually results in something so complex that it turns into newbie-repellent.
<br />
<li>So please feel free to use and/or customize setupServer.py to taste, or write your own in Python or another language.
<br />
<li>Also, you may want to write a script which handles the startup of the I2P Router, the eepProxy, plus any and all tunnels you are using. I've got such a script called startEverything.sh, which gets launched at system startup. (Be sure to search this site for template scripts to automate your I2P commands. If I create a page for one, I'll try to remember to link it here.
<br />
<li>Exercise for Windows users - port setupServer.py into a MS-DOS .BAT file.
<br />
</ul>
{% endblock %}

122
i2p2www/pages/site/misc/jbigi.html Normal file
View File

@@ -0,0 +1,122 @@
{% extends "global/layout.html" %}
{% block title %}jbigi{% endblock %}
{% block lastupdated %}August 2011{% endblock %}
{% block accuratefor %}0.8.7{% endblock %}
{% block content %}
<h2>Overview</h2>
<p>Using JNI (Java Native Interface), a bit of C code (thanks ugha!), a little
manual work and a piece of chewing gum we have made several
cryptography operations quite a bit faster.</p>
<p>
The speedup comes from the super-fast
<a href="http://gmplib.org/">GNU MP Bignum library (libgmp)</a>.
We use a single function from libgmp -
<a href="http://gmplib.org/manual-4.3.2/Integer-Exponentiation.html#Integer-Exponentiation">mpz_powm()</a>
as a replacement for the
<a href="http://download.oracle.com/javase/1.5.0/docs/api/java/math/BigInteger.html#modPow%28java.math.BigInteger,%20java.math.BigInteger%29">Java Math library's BigInteger modPow()</a>.
As modPow() is a significant computational portion of many crypto operations, this is of significant benefit.
</p>
<p>
The standard I2P installation includes about 20 versions of the library for different platforms,
each about 50KB, inside the jbigi.jar file.
The initialization of the JBigI library, including CPU identification, selection, and extraction
of the correct loadable module, is handled by the
<a href="http://docs.i2p-projekt.de/javadoc/net/i2p/util/NativeBigInteger.html">NativeBigInteger class</a>.
If no module is available for the current platform, the standard
<a href="http://download.oracle.com/javase/1.5.0/docs/api/java/math/BigInteger.html#modPow%28java.math.BigInteger,%20java.math.BigInteger%29">Java Math library's BigInteger modPow()</a>
is used.
</p>
<h2>Rebuilding and Testing JBigI</h2>
Following are the instructions to build a new jbigi library for your own platform
and testing its performance.
<h3>Requirements</h3>
<p>This works on Linux, and with a few changes in build.sh probably also on
other platforms. FreeBSD has also been reported to work too. On Kaffee the
speedup is very small, because it already uses native BitInteger internally.
Blackdown seems to cause strange errors. Because you are going to do
compilation, you need JDK; JRE won't work.</p>
<p>The required code is available in monotone database and the latest source tarball.</p>
<p>The GNU MP Bignum library (libgmp) needs to be installed, if it isn't
included in your OS / distribution or installed already, it can be received from
<a href="http://gmplib.org/#DOWNLOAD">http://gmplib.org/#DOWNLOAD</a>. Even if you
have already installed it as binary, it might still be worth a try to compile
GMP yourself, since then it will be able to use the specific instructions of
your processor. The latest GMP may also
be used instead of GMP 5.0.2, but it hasn't been tested by us.
</p>
<h3>Step-by-step instructions</h3>
<ol>
<li>Look at <a href="http://localhost:7657/logs.jsp">your running environment on the logs.jsp page</a>.
There should be one of two status messages for JBigI - either
<tt>
Locally optimized native BigInteger loaded from the library path
</tt>
or
<tt>
Native BigInteger library jbigi not loaded - using pure java</tt>.
If the native BitInteger library was NOT loaded, you definitely need to
compile your own.
Certain platforms, such as OS X, OpenSolaris, and 64-bit systems,
may require you to compile your own library.
If the BigInteger library was loaded, do at least the next step to see
what your performance is.
</li>
<li>Look on <a href="http://localhost:7657/stats.jsp">http://localhost:7657/stats.jsp</a>
to see what the lifetime average values for <code>crypto.elGamal.decrypt</code> and
<code>crypto.elGamal.encrypt</code> are. The numbers are times in milliseconds. Copy these somewhere so you can compare
them later on.
The network average for encrypt time is about 20ms.
If your encrypt time is less than 50ms for a relatively new processor, or less than 100ms
for an older processor, and the native BigInteger library was loaded, you are probably fine.
</li>
<li>Get the latest released source code of I2P from
<a href="{{ url_for('downloads_list', lang=g.lang) }}">the download page</a>, or get the cutting-edge source
out of the monotone database mtn.i2p2.de</li>
<li>Inside the source tree change directory to: <code>core/c/jbigi</code></li>
<li>Read the README file.
If you have a /usr/lib/libgmp.so file, you do not have to download GMP.
Use the 'dynamic' argument to build.sh.
Otherwise, you must download GMP version 5.0.2 from
from <a href="http://gmplib.org/#DOWNLOAD">http://gmplib.org/#DOWNLOAD</a>, saving it to gmp-5.0.2.tar.bz2.
If you decide to use a newer version, change the VER= line in <code>core/c/jbigi/build.sh</code>.
<li>Take a look at <code>build.sh</code>, if your <code>JAVA_HOME</code>
environment variable is set and you are using Linux then it might just work.
Otherwise change the settings. Remember, you need the Java SDK installed.</li>
<li>Run <code>build.sh</code> (if you downloaded GMP) or
<code>build.sh dynamic</code> (if you have /usr/lib/libgmp.so).<br/>
Maybe the build spewed out some errors of missing jni.h and jni_md.h files.
Either copy these files from your java install into the core/c/jbigi/jbigi/include/ directory,
or fix $JAVA_HOME.<br>
You can run the <code>build.sh</code> from the <code>core/c/</code> directory which will
build all available jbigi libs into a jbigi.jar.</br>
A file named <code>libjbigi.so</code> should be created in the current
directory. If this doesn't happen and/or you get errors then please report
them.</li>
<li>Follow the instructions in core/c/README to install the library and run
the speed test.
Read the final lines of the speed test's output for some additional
info, it will be something like this:
<pre>
native run time: 5842ms ( 57ms each)
java run time: 41072ms (406ms each)
native = 14.223802103622907% of pure java time
</pre>
If the native is indeed 5-7x faster (or more) then it looks all good. If not, please
report.</li>
<li>Copy <code>libjbigi.so</code> to your i2p directory</li>
<li>Restart your I2P programs.</li>
<li>On
<a href="http://localhost:7657/stats.jsp">http://localhost:7657/stats.jsp</a>
the <code>crypto.elGamal.decrypt</code> and <code>crypto.elGamal.encrypt</code>
should be a lot faster.</li>
</ol>
{% endblock %}

54
i2p2www/pages/site/misc/manualwrapper.html Normal file
View File

@@ -0,0 +1,54 @@
{% extends "global/layout.html" %}
{% block title %}Manually Installing the Java Wrapper{% endblock %}
{% block content %}
<h1>Manually Installing the Java Wrapper</h1>
<p>The installation package for the <a href="{{ url_for('downloads_list', lang=g.lang) }}">I2P router</a> comes
with a Java wrapper for the most common architectures. If your system is not
supported by our installer&mdash;or if you want to update the wrapper to a
newer version&mdash;the following steps describe installing the wrapper manually.
</p>
<ul>
<li> Check Tanuki Software's <a href="http://wrapper.tanukisoftware.com/doc/english/download.jsp#stable">download page</a>
for your platform. Is your platform listed? If so, you're in
luck! Download the most recent version of the Community Edition for your OS and
CPU and move to <a href="#packaged">the next step</a></li>
<li>If your platform does not have an already compiled wrapper available, you
may be able to compile it yourself. If you are willing to have a go at it, move
on to <a href="#compiling">compiling</a> the wrapper for your system.</li>
</ul>
<h2 id="packaged">Using existing binaries</h2>
In the steps below, $I2P means <em>the location I2P was installed to</em>.
<ol>
<li><code>tar xzf wrapper-*.tar.gz</code></li>
<li><code>cp wrapper*/bin/wrapper $I2P/i2psvc</code></li>
<li><code>cp wrapper*/lib/wrapper.jar $I2P/lib</code></li>
<li><code>cp wrapper*/lib/libwrapper.so $I2P/lib</code></li>
<li>Try to start I2P using <code>$I2P/i2prouter start</code></li>
<li><code>tail -f /tmp/wrapper.log</code> and look for any problems.</li></ol>
If this did not work you'll need to use <code>runplain.sh</code> to start I2P.
<h2 id="compiling">Compiling from source</h2>
These steps worked to compile the wrapper for use on a mipsel system running Debian. The steps <strong>will</strong> need to be altered for your system.
<ol>
<li>Download the source archive for the community version of the wrapper from <a href="http://wrapper.tanukisoftware.com/downloads">wrapper download page</a>.</li>
<li>Extract the tarball<br />
&nbsp;&nbsp;&nbsp;&nbsp;<code>tar xzf wrapper_3.5.13_src.tar.gz</code></li>
<li>Set environment variables ANT_HOME and JAVA_HOME. In Debian, one can<br />
&nbsp;&nbsp;&nbsp;&nbsp;<code>export ANT_HOME=/usr/share/ant</code><br />
&nbsp;&nbsp;&nbsp;&nbsp;<code>export JAVA_HOME=/usr/lib/jvm/default-java</code></li>
<li>Since there isn't a Makefile for Mipsel, we'll make a copy of an already existing makefile<br />
&nbsp;&nbsp;&nbsp;&nbsp;<code>cp src/c/Makefile-linux-x86-32.make src/c/Makefile-linux-mipsel-32.make</code></li>
<li>Now we can attempt to compile the wrapper<br />
&nbsp;&nbsp;&nbsp;&nbsp;<code>./build32.sh</code> (use <code>./build64.sh</code> if you have a 64bit CPU and JVM)</li>
<li>Copy the wrapper into its proper place:
<ul>
<li><code>cp bin/wrapper $I2P/i2psvc</code></li>
<li><code>cp lib/wrapper.jar $I2P/lib</code></li>
<li><code>cp lib/libwrapper.so $I2P/lib</code></li>
</ul></li>
<li>Try to start I2P using <code>$I2P/i2prouter start</code></li>
<li><code>tail -f /tmp/wrapper.log</code> and look for any problems.</li>
</ol>
If this did not work you'll need to use <code>runplain.sh</code> to start I2P.
{% endblock %}

103
i2p2www/pages/site/misc/minwww.html Normal file
View File

@@ -0,0 +1,103 @@
{% extends "global/layout.html" %}
{% block title %}minwww{% endblock %}
{% block content %}<p>Here's an outline and rationale for a minimal WWW proxy app for use over
I2P.</p>
<p>HTTP operation over I2P using I2PTunnel. When the base SocketLibrary
is out, the only significant difference will be the 'wrapRequest' and
'unwrapRequest' will functionally be placed in the socketLibrary, not
in the router (but later versions of the SocketLibrary will be able to
use selective ACK and large window sizes, allowing more ACKs to be
skipped)</p>
<pre>
---BROWSER---&gt;-I2PTUNNEL---&gt;-ROUTERA---&gt;-ROUTERB---&gt;-I2PTUNNEL---&gt;-HTTPD----------
1: openCon
2: requestCon
3: wrapRequest
4: unwrapRequest
5: receiveACK receiveCon
6: sentSuccess sendSYN
7: wrapRequest
8: unwrapRequest
9: receiveSYN receiveACK
10: "GET /" sentSuccess
11: sendData
12: wrapRequest
13: unwrapRequest
14: receiveACK receiveData
15: sentSuccess "GET /"
16: "HTTP 200\n\nHi"
17: sendData
18: wrapRequest
19: unwrapRequest
20: receiveData receiveACK
21: "HTTP 200\n\nHi" sentSuccess
22: closeCon
23: sendClose
24: wrapRequest
25: unwrapRequest
26: receiveACK receiveClose
27: sentSuccess
</pre>
<p>An optimized form, designed to handle only 128KB [1] files and pages, can
operate significantly faster:</p>
<pre>
BROWSER --&gt; MinWWW --&gt; ROUTERA --&gt; ROUTERB --&gt; MinWWW --&gt; HTTPD
1: openCon
2: opened
3: "GET /"
4: sendData
5: forward
6: receive
7: receiveData
8: "GET /"
9: "HTTP 200\n\nHi"
10: sendData
11: forward
12: receive
13: receiveData
14: "HTTP 200\n\nHi"
15: closeCon
16: closed
</pre>
<p>The difference in network load and latency is significant - this is
essentially a UDP version of HTTP. On the normal web, we can't really do that,
since most HTTP requests and responses are orders of magnitude larger than UDP
packets functionally support, but in I2P, messages can be large. The savings
for the network load comes from the fact that we don't need to send any ACK
messages - rather than the earlier wrap/unwrap request (that bundles a
DataMessage with a DeliveryStatusMessage to provide guaranteed delivery), the
MinWWW proxy deals with resends (if necessary - in I2PTunnel today, there are no
resends).</p>
<p>The data that the MinWWW proxy and server need to wrap is trivial - when the
proxy wants to send "GET /", it prepends it with the I2P Destination sending
the request, followed by a 4 byte request ID. The MinWWW server receives those
requests, contacts the appropriate HTTPD, sends the request, waits for the
response, and sends a reply to the MinWWW proxy containing the response,
prefixed with the original request ID. That response is taken and passed back
to the browser and the connection is closed.</p>
<p>In addition, the MinWWW proxy can choose the MinWWW server to use from a
list, going through some round robin or other algorithm, so that there are
multiple outproxies merged transparently. The bandwidth required for running
one of these outproxies is also greatly reduced, since it will only handle 128KB
files (aka no one is going to be downloading porn, warez, etc).</p>
<p>The functionality /is/ limited, but 128KB of data is a lot for a single HTTP
request or response. The above diagrams are also unrealistic in their hops -
ROUTERA will really never talk directly to ROUTERB. ROUTERA will send each
of the messages through two additional outbound routers, then forwarded to
two additional inbound routers to ROUTERB, so the lag there is significant -
while the above only saves 11 steps, 8 of those steps need to traverse the
entire tunnel path (4+ remote hops each time when tunnels are 2 remote hops
in each stretch), leaving MinWWW with only two full traversals (one for the
request, one for the response), instead of 10.</p>
<p>Implementing the MinWWW proxy and server should be fairly easy - read an HTTP
request from the client fully (perhaps only start out with HTTP GET, leaving
HTTP POST for later), wrap the message, and wait for the response. The server
in turn simply needs to parse the request to either open a socket or URL,
send the request, wait for the response, and send it back through the network.
If someone were to implement this, it would be Good :)</p>
<p>[1] Why 128KB files? Currently I2CP allows functionally arbitrary message
size, but that's going to be going away since it involves either excessive memory
overhead on intermediary routers, or additional implementation details to
handle. I2PTunnel is currently limited to 128KB and hasn't been a burden,
so perhaps it could be increased to 256KB when the I2CP spec is updated)</p>
{% endblock %}

522
i2p2www/pages/site/misc/ratestats.html Normal file
View File

@@ -0,0 +1,522 @@
{% extends "global/layout.html" %}
{% block title %}RateStat list{% endblock %}
{% block content %}
<h1>RateStat list</h1>
<p>I2P enables the collection of a wide range of rates, the list published here is accurate as of I2P version 0.8.7.</p>
<p>The list was gathered using the following command in the top directory of the branch i2p.i2p,
<pre> find . -name '*' -print | xargs --max-args=3 grep -n --color=auto addRateData | awk 'match($0, /addRateData\(\"(.*)\"/, a) {print a[1]}' | awk '!_[$0]++' | sort > rates.txt
</pre>
All options aren't needed, but it works.
</p>
<h2>RateStats</h2>
<div class="box" style="clear: none;"><pre>
bwLimiter.inboundDelayedTime
bwLimiter.outboundDelayedTime
bwLimiter.pendingInboundRequests
bwLimiter.pendingOutboundRequests
bw.receiveBps
bw.recvRate
bw.sendBps
bw.sendRate
byteCache.memory.
client.dispatchNoACK
client.dispatchNoTunnels
client.dispatchPrepareTime
client.dispatchSendTime
client.dispatchTime
client.distributeTime
client.leaseSetFailedRemoteTime
client.leaseSetFoundLocally
client.leaseSetFoundRemoteTime
client.receiveMessageSize
client.requestLeaseSetDropped
client.requestLeaseSetSuccess
client.requestLeaseSetTimeout
client.sendAckTime
client.sendDropped
client.sendMessageSize
client.sendThrottled
client.timeoutCongestionInbound
client.timeoutCongestionMessage
client.timeoutCongestionTunnel
clock.skew
crypto.dhCalculateSessionTime
crypto.DHEmpty
crypto.dhGeneratePublicTime
crypto.DHUsed
crypto.elGamal.decrypt
crypto.elGamal.encrypt
crypto.garlic.decryptFail
crypto.sessionTagsExpired
crypto.sessionTagsRemaining
crypto.YKEmpty
crypto.YKUsed
i2cp.checkStatusTime
i2cp.receiveStatusTime
i2cp.receiveStatusTime.1
i2cp.receiveStatusTime.2
i2cp.receiveStatusTime.3
i2cp.receiveStatusTime.4
i2cp.receiveStatusTime.5
i2cp.sendBestEffortStage0
i2cp.sendBestEffortStage1
i2cp.sendBestEffortStage2
i2cp.sendBestEffortStage3
i2cp.sendBestEffortStage4
i2cp.sendBestEffortTotalTime
i2cp.tx.msgCompressed
i2cp.tx.msgExpanded
i2np.readTime
i2np.writeTime
i2ptunnel.httpCompressed
i2ptunnel.httpCompressionRatio
i2ptunnel.httpExpanded
i2ptunnel.httpNullWorkaround
i2ptunnel.httpserver.blockingHandleTime
inNetPool.dropped
inNetPool.droppedDbLookupResponseMessage
inNetPool.droppedDeliveryStatusDelay
inNetPool.droppedTunnelCreateStatusMessage
inNetPool.duplicate
jobQueue.droppedJobs
jobQueue.jobLag
jobQueue.jobRun
jobQueue.jobRunnerInactive
jobQueue.jobRunSlow
jobQueue.jobWait
jobQueue.readyJobs
netDb.ackTime
netDb.exploreKeySet
netDb.failedAttemptedPeers
netDb.failedPeers
netDb.failedTime
netDb.floodfillVerifyFail
netDb.floodfillVerifyOK
netDb.floodfillVerifyTimeout
netDb.floodThrottled
netDb.KBSGetAllTime
netDb.lookupLeaseSetDeferred
netDb.lookupsDropped
netDb.lookupsHandled
netDb.lookupsMatched
netDb.lookupsMatchedLeaseSet
netDb.lookupsMatchedLocalClosest
netDb.lookupsMatchedLocalNotClosest
netDb.lookupsMatchedReceivedPublished
netDb.lookupsMatchedRemoteNotClosest
netDb.lookupsReceived
netDb.newFSC
netDb.replyTimeout
netDb.republishLeaseSetCount
netDb.republishQuantity
netDb.searchCount
netDb.searchMessageCount
netDb.searchReplyMessageReceive
netDb.searchReplyNotValidated
netDb.searchReplyValidated
netDb.searchReplyValidationSkipped
netDb.storeFailedPeers
netDb.storeFloodNew
netDb.storeFloodOld
netDb.storeHandled
netDb.storeLeaseSetHandled
netDb.storeLeaseSetSent
netDb.storeLocalLeaseSetAttempt
netDb.storeLocalRouterInfoAttempt
netDb.storePeers
netDb.storeRecvTime
netDb.storeRouterInfoHandled
netDb.storeRouterInfoSent
netDb.successPeers
netDb.successTime
netDb.writeClobber
netDb.writeOut
netDb.writePending
netDb.writeTime
ntcp.accept
ntcp.attemptShitlistedPeer
ntcp.attemptUnreachablePeer
ntcp.bidRejectedLocalAddress
ntcp.bidRejectedNoNTCPAddress
ntcp.closeOnBacklog
ntcp.connectBlocklisted
ntcp.connectFailedInvalidPort
ntcp.connectFailedIOE
ntcp.connectFailedTimeout
ntcp.connectFailedTimeoutIOE
ntcp.connectFailedUnresolved
ntcp.connectImmediate
ntcp.connectSuccessful
ntcp.corruptDecryptedI2NP
ntcp.corruptI2NPCRC
ntcp.corruptI2NPIME
ntcp.corruptI2NPIOE
ntcp.corruptMetaCRC
ntcp.corruptSkew
ntcp.corruptTooLargeI2NP
ntcp.dontSendOnBacklog
ntcp.failsafeCloses
ntcp.failsafeInvalid
ntcp.failsafeWrites
ntcp.floodInfoMessageEnqueued
ntcp.inboundCheckConnection
ntcp.inboundEstablished
ntcp.inboundEstablishedDuplicate
ntcp.infoMessageEnqueued
ntcp.invalidDH
ntcp.invalidHXxorBIH
ntcp.invalidHXY
ntcp.invalidInboundDFE
ntcp.invalidInboundIOE
ntcp.invalidInboundSignature
ntcp.invalidInboundSize
ntcp.invalidInboundSkew
ntcp.invalidOutboundSkew
ntcp.invalidSignature
ntcp.liveReadBufs
ntcp.multipleCloseOnRemove
ntcp.noBidTooLargeI2NP
ntcp.outboundEstablishFailed
ntcp.outboundFailedIOEImmediate
ntcp.prepBufCache
ntcp.queuedRecv
ntcp.read
ntcp.readEOF
ntcp.readError
ntcp.receiveCorruptEstablishment
ntcp.receiveMeta
ntcp.receiveSize
ntcp.receiveTime
ntcp.registerConnect
ntcp.sendBacklogTime
ntcp.sendFinishTime
ntcp.sendQueueSize
ntcp.sendTime
ntcp.throttledReadComplete
ntcp.throttledWriteComplete
ntcp.transmitTime
ntcp.wantsQueuedWrite
ntcp.write
ntcp.writeError
outNetMessage.timeToDiscard
peer.failedLookupRate
peer.profileCoalesceTime
peer.profilePlaceTime
peer.profileReorgTime
peer.profileSortTime
peer.profileThresholdTime
peer.testOK
peer.testTimeout
peer.testTooSlow
pool.dispatchDataTime
pool.dispatchGatewayTime
prng.bufferFillTime
prng.bufferWaitTime
prng.reseedCount
router.activePeers
router.activeSendPeers
router.decayingBloomFilter." + _name + ".dups
router.decayingBloomFilter." + _name + ".log10(falsePos)
router.decayingBloomFilter." + _name + ".size
router.decayingHashSet." + _name + ".dups
router.decayingHashSet." + _name + ".size
router.duplicateMessageId
router.fastPeers
router.highCapacityPeers
router.invalidMessageTime
router.memoryUsed
router.throttleNetDbCause
router.throttleNetDbDoS
router.throttleNetDbDoSSend
router.throttleNetworkCause
router.throttleTunnelBandwidthExceeded
router.throttleTunnelBytesAllowed
router.throttleTunnelBytesUsed
router.throttleTunnelMaxExceeded
router.throttleTunnelProbTestSlow
router.throttleTunnelProbTooFast
router.throttleTunnelQueueOverload
send." + _connectionId + ".lifetime
send." + _connectionId + ".started
send." + _connectionId + ".totalSent
sink." + _connectionId + ".lifetime
stream.chokeSizeBegin
stream.chokeSizeEnd
stream.con.initialRTT.in
stream.con.initialRTT.out
stream.con.lifetimeBytesReceived
stream.con.lifetimeBytesSent
stream.con.lifetimeCongestionSeenAt
stream.con.lifetimeDupMessagesReceived
stream.con.lifetimeDupMessagesSent
stream.con.lifetimeMessagesReceived
stream.con.lifetimeMessagesSent
stream.con.lifetimeRTT
stream.con.lifetimeSendWindowSize
stream.connectionCreated
stream.connectionReceived
stream.con.packetsAckedPerMessageReceived
stream.con.receiveDuplicateSize
stream.con.receiveMessageSize
stream.con.sendDuplicateSize
stream.con.sendMessageSize
stream.con.throttledDay
stream.con.throttledHour
stream.con.throttledMinute
stream.con.windowSizeAtCongestion
stream.fastRetransmit
streaming.ackSendFailed
streaming.lifetime
streaming.nackReceived
streaming,nackSent
streaming.nackSent
streaming.received
streaming.sent
streaming.synNoAck
streaming.transferBalance
stream.packetReceiveFailure
stream.receiveActive
stream.resetReceived
stream.sendBps
stream.sendsBeforeAck
stream.trend
swarm." + _connectionId + ".lifetime
swarm." + _connectionId + ".started
swarm." + _connectionId + ".totalSent
swarm." + getConnectionId() + ".totalReceived
transport.bidFailAllTransports
transport.bidFailNoTransports
transport.bidFailSelf
transport.bidFailShitlisted
transport.expiredOnQueueLifetime
transport.getBidsJobTime
transport.noBidsYetNotAllUnreachable
transport.receiveMessageLarge
transport.receiveMessageMedium
transport.receiveMessageSize
transport.receiveMessageSmall
transport.receiveMessageTime
transport.receiveMessageTimeSlow
transport.sendMessageFailureLifetime
transport.sendMessageLarge
transport.sendMessageMedium
transport.sendMessageSize
transport.sendMessageSmall
transport.sendProcessingTime
transport.shitlistOnUnreachable
tunnel.acceptLoad
tunnel.batchCount
tunnel.batchDelay
tunnel.batchDelayAmount
tunnel.batchDelaySent
tunnel.batchFlushRemaining
tunnel.batchFragmentation
tunnel.batchFullFragments
tunnel.batchMultipleCount
tunnel.batchSmallFragments
tunnel.buildClientExpire
tunnel.buildClientReject
tunnel.buildClientSuccess
tunnel.buildExploratoryExpire
tunnel.buildExploratoryReject
tunnel.buildExploratorySuccess
tunnel.buildFailFirstHop
tunnel.buildReplySlow
tunnel.buildReplyTooSlow
tunnel.buildRequestDup
tunnel.buildRequestTime
tunnel.buildRequestZeroHopTime
tunnel.bytesAllocatedAtAccept
tunnel.concurrentBuilds
tunnel.concurrentBuildsLagged
tunnel.corruptBuildReply
tunnel.corruptMessage
tunnel.decryptRequestTime
tunnel.dispatchDataTime
tunnel.dispatchEndpoint
tunnel.dispatchGatewayTime
tunnel.dispatchInbound
tunnel.dispatchOutboundPeer
tunnel.dispatchOutboundTime
tunnel.dispatchOutboundTunnel
tunnel.dispatchOutboundZeroHopTime
tunnel.dispatchParticipant
tunnel.dropConnLimits
tunnel.dropDangerousClientTunnelMessage
tunnel.dropLoad
tunnel.dropLoadBacklog
tunnel.dropLoadDelay
tunnel.dropLoadProactive
tunnel.dropLoadProactiveAbort
tunnel.duplicateIV
tunnel.failedCompletelyMessages
tunnel.failedPartiallyMessages
tunnel.fragmentedComplete
tunnel.fragmentedDropped
tunnel.fullFragments
tunnel.handleLoadClove
tunnel.handleRemaining
tunnel.joinInboundEndpoint
tunnel.joinInboundEndpointZeroHop
tunnel.joinInboundGateway
tunnel.joinOutboundEndpoint
tunnel.joinOutboundGateway
tunnel.joinOutboundGatewayZeroHop
tunnel.joinParticipant
tunnel.lockedGatewayAdd
tunnel.lockedGatewayCheck
tunnel.ownedMessageCount
tunnel.participatingBandwidth
tunnel.participatingBandwidthOut
tunnel.participatingMessageCount
tunnel.participatingMessageDropped
tunnel.participatingTunnels
tunnel.pendingRemaining
tunnel.receiveRejectionBandwidth
tunnel.receiveRejectionCritical
tunnel.receiveRejectionProbabalistic
tunnel.receiveRejectionTransient
tunnel.reject.
tunnel.rejectOverloaded
tunnel.rejectTimeout
tunnel.rejectTimeout2
tunnel.smallFragments
tunnel.testAborted
tunnel.testExploratoryFailedCompletelyTime
tunnel.testExploratoryFailedTime
tunnel.testFailedCompletelyTime
tunnel.testFailedTime
tunnel.testSuccessLength
tunnel.testSuccessTime
tunnel.tierAgree
tunnel.tierExpire
tunnel.tierReject
tunnel.writeDelay
udp.abortACK
udp.acceptedInboundProbabalistically
udp.ackFrequency
udp.activeDelay
udp.addressTestInsteadOfUpdate
udp.addressUpdated
udp.allowConcurrentActive
udp.alreadyConnected
udp.blockedRetransmissions
udp.congestedRTO
udp.congestionOccurred
udp.droppedInbound
udp.droppedInboundProbabalistically
udp.droppedInvalidEstablish
udp.droppedInvalidEstablish.inbound
udp.droppedInvalidEstablish.new
udp.droppedInvalidEstablish.outbound
udp.droppedInvalidInboundEstablish
udp.droppedInvalidReestablish
udp.droppedInvalidSkew
udp.droppedInvalidUnknown
udp.droppedPeer
udp.dropPeerConsecutiveFailures
udp.dropPeerDroplist
udp.establishOverflow
udp.establishRejected
udp.fetchRemoteSlow
udp.handleTime
udp.ignorePacketFromDroplist
udp.ignoreRecentDuplicate
udp.inboundEstablishFailedState
udp.inboundEstablishTime
udp.inboundExpired
udp.inboundLag
udp.inboundReadTime
udp.inboundReady
udp.inboundReceiveProcessTime
udp.inboundRemaining
udp.messageQueueSize
udp.mtuDecrease
udp.mtuIncrease
udp.outboundActiveCount
udp.outboundEstablishFailedState
udp.outboundEstablishTime
udp.packetAuthRecvTime
udp.packetAuthTime
udp.packetAuthTimeSlow
udp.packetDequeueTime
udp.packetNoValidationLifetime
udp.packetsRetransmitted
udp.packetValidateMultipleCount
udp.packetVerifyTime
udp.packetVerifyTimeSlow
udp.partialACKReceived
udp.peerPacketsRetransmitted
udp.proactiveReestablish
udp.pushTime
udp.queueAllowTotalLifetime
udp.queueDropSize
udp.queueTime
udp.receiveACKPeriod
udp.receiveBps
udp.receivedACKs
udp.receivedCompleteFragments
udp.receivedCompleteTime
udp.receiveHolePunch
udp.receiveIntroRelayResponse
udp.receiveMessagePeriod
udp.receivePacketSize
udp.receivePacketSize.dataKnown
udp.receivePacketSize.dataKnownAck
udp.receivePacketSize.dataUnknown
udp.receivePacketSize.dataUnknownAck
udp.receivePacketSize.relayIntro
udp.receivePacketSize.relayRequest
udp.receivePacketSize.relayResponse
udp.receivePacketSize.sessionConfirmed
udp.receivePacketSize.sessionCreated
udp.receivePacketSize.sessionRequest
udp.receivePacketSize.test
udp.receivePacketSkew
udp.receivePiggyback
udp.receiveRelayIntro
udp.receiveRelayRequest
udp.receiveRelayRequestBadTag
udp.receiveRemaining
udp.receiveTest
udp.receiveTestReply
udp.rejectConcurrentActive
udp.rejectConcurrentSequence
udp.sendACKCount
udp.sendACKPartial
udp.sendACKRemaining
udp.sendACKTime
udp.sendAggressiveFailed
udp.sendBps
udp.sendBWThrottleTime
udp.sendConfirmFragments
udp.sendConfirmTime
udp.sendConfirmVolley
udp.sendCycleTime
udp.sendCycleTimeSlow
udp.sendException
udp.sendFailed
udp.sendIntroRelayRequest
udp.sendIntroRelayTimeout
udp.sendPacketSize
udp.sendPacketSize.
udp.sendPiggyback
udp.sendPiggybackPartial
udp.sendQueueFailed
udp.sendQueueSize
udp.sendQueueTrimmed
udp.sendRejected
udp.sendSparse
udp.sendVolleyTime
udp.socketSendTime
udp.statusDifferent
udp.statusKnownCharlie
udp.statusOK
udp.statusReject
udp.statusUnknown
udp.timeToActive
udp.timeToEntrance
</pre></div>
{% endblock %}