" + + "
" + _t("You can browse to the site without saving it to the address book. The address will be remembered until you restart your I2P router.") + - "
" + - _t("This address will be saved to your Router address book where your subscription-based addresses are stored.")); - if(_context.namingService().getName().equals("BlockfileNamingService")) { - out.write(" " + _t("If you want to keep track of sites you have added manually, add to your Local or Private address book instead.")); - } // FIXME wasn't escaped String label = _t("Save & continue").replace("&", "&"); - out.write("
" + + _t("This address will be saved to your Router address book where your subscription-based addresses are stored.")); + if(_context.namingService().getName().equals("BlockfileNamingService")) { + out.write(" " + _t("If you want to keep track of sites you have added manually, add to your Local or Private address book instead.")); + } + out.write("
" + + out.write("
" + _t("This address will be saved to your Local address book. Select this option for addresses you wish to keep separate from the main router address book, but don't mind publishing.") + - "
" + _t("This address will be saved to your Private address book, ensuring it is never published.") + - "
PSK: " + _t("Enter PSK encryption key") + - ": ]
DH: " + _t("Generate new DH encryption key") + ":
" + _t("Click here if you are not redirected automatically.") + "
<%=intl._t("These are the local services provided by your router.")%> @@ -177,7 +179,7 @@ } // encName %>
"); out.println(_t("Please report bugs on {0} or {1}.", - "trac.i2p2.i2p", - "trac.i2p2.de")); + "git.idk.i2p", + "i2pgit.org")); out.println("
"); out.println(_t("Please include this information in bug reports") + ':'); out.print("
+ * The connector uses an {@link EndPoint} (typically {@link SelectChannelEndPoint}) as + * it's source/sink of encrypted data. It then provides an endpoint via {@link #getDecryptedEndPoint()} to + * expose a source/sink of unencrypted data to another connection (eg HttpConnection). + *
+ * The design of this class is based on a clear separation between the passive methods, which do not block nor schedule any + * asynchronous callbacks, and active methods that do schedule asynchronous callbacks. + *
+ * The passive methods are {@link DecryptedEndPoint#fill(ByteBuffer)} and {@link DecryptedEndPoint#flush(ByteBuffer...)}. They make best + * effort attempts to progress the connection using only calls to the encrypted {@link EndPoint#fill(ByteBuffer)} and {@link EndPoint#flush(ByteBuffer...)} + * methods. They will never block nor schedule any readInterest or write callbacks. If a fill/flush cannot progress either because + * of network congestion or waiting for an SSL handshake message, then the fill/flush will simply return with zero bytes filled/flushed. + * Specifically, if a flush cannot proceed because it needs to receive a handshake message, then the flush will attempt to fill bytes from the + * encrypted endpoint, but if insufficient bytes are read it will NOT call {@link EndPoint#fillInterested(Callback)}. + *
+ * It is only the active methods : {@link DecryptedEndPoint#fillInterested(Callback)} and + * {@link DecryptedEndPoint#write(Callback, ByteBuffer...)} that may schedule callbacks by calling the encrypted + * {@link EndPoint#fillInterested(Callback)} and {@link EndPoint#write(Callback, ByteBuffer...)} + * methods. For normal data handling, the decrypted fillInterest method will result in an encrypted fillInterest and a decrypted + * write will result in an encrypted write. However, due to SSL handshaking requirements, it is also possible for a decrypted fill + * to call the encrypted write and for the decrypted flush to call the encrypted fillInterested methods. + *
+ * MOST IMPORTANTLY, the encrypted callbacks from the active methods (#onFillable() and WriteFlusher#completeWrite()) do no filling or flushing + * themselves. Instead they simple make the callbacks to the decrypted callbacks, so that the passive encrypted fill/flush will + * be called again and make another best effort attempt to progress the connection. + * + */ +public class SslConnection extends AbstractConnection +{ + private static final Logger LOG = Log.getLogger(SslConnection.class); + + private final List handshakeListeners = new ArrayList<>(); + private final ByteBufferPool _bufferPool; + private final SSLEngine _sslEngine; + private final DecryptedEndPoint _decryptedEndPoint; + private ByteBuffer _decryptedInput; + private ByteBuffer _encryptedInput; + private ByteBuffer _encryptedOutput; + private final boolean _encryptedDirectBuffers; + private final boolean _decryptedDirectBuffers; + private boolean _renegotiationAllowed; + private int _renegotiationLimit = -1; + private boolean _closedOutbound; + private boolean _allowMissingCloseMessage = true; + private final Runnable _runCompletWrite = new Runnable() + { + @Override + public void run() + { + _decryptedEndPoint.getWriteFlusher().completeWrite(); + } + }; + private final Runnable _runFillable = new Runnable() + { + @Override + public void run() + { + _decryptedEndPoint.getFillInterest().fillable(); + } + }; + private final Callback _nonBlockingReadCallback = new Callback.NonBlocking() + { + @Override + public void succeeded() + { + onFillable(); + } + + @Override + public void failed(final Throwable x) + { + onFillInterestedFailed(x); + } + + @Override + public String toString() + { + return String.format("SSLC.NBReadCB@%x{%s}", SslConnection.this.hashCode(),SslConnection.this); + } + }; + + public SslConnection(ByteBufferPool byteBufferPool, Executor executor, EndPoint endPoint, SSLEngine sslEngine) + { + this(byteBufferPool, executor, endPoint, sslEngine, false, false); + } + + public SslConnection(ByteBufferPool byteBufferPool, Executor executor, EndPoint endPoint, SSLEngine sslEngine, + boolean useDirectBuffersForEncryption, boolean useDirectBuffersForDecryption) + { + // This connection does not execute calls to onFillable(), so they will be called by the selector thread. + // onFillable() does not block and will only wakeup another thread to do the actual reading and handling. + super(endPoint, executor); + this._bufferPool = byteBufferPool; + this._sslEngine = sslEngine; + this._decryptedEndPoint = newDecryptedEndPoint(); + this._encryptedDirectBuffers = useDirectBuffersForEncryption; + this._decryptedDirectBuffers = useDirectBuffersForDecryption; + } + + public void addHandshakeListener(SslHandshakeListener listener) + { + handshakeListeners.add(listener); + } + + public boolean removeHandshakeListener(SslHandshakeListener listener) + { + return handshakeListeners.remove(listener); + } + + protected DecryptedEndPoint newDecryptedEndPoint() + { + return new DecryptedEndPoint(); + } + + public SSLEngine getSSLEngine() + { + return _sslEngine; + } + + public DecryptedEndPoint getDecryptedEndPoint() + { + return _decryptedEndPoint; + } + + public boolean isRenegotiationAllowed() + { + return _renegotiationAllowed; + } + + public void setRenegotiationAllowed(boolean renegotiationAllowed) + { + _renegotiationAllowed = renegotiationAllowed; + } + + /** + * @return The number of renegotions allowed for this connection. When the limit + * is 0 renegotiation will be denied. If the limit is less than 0 then no limit is applied. + */ + public int getRenegotiationLimit() + { + return _renegotiationLimit; + } + + /** + * @param renegotiationLimit The number of renegotions allowed for this connection. + * When the limit is 0 renegotiation will be denied. If the limit is less than 0 then no limit is applied. + * Default -1. + */ + public void setRenegotiationLimit(int renegotiationLimit) + { + _renegotiationLimit = renegotiationLimit; + } + + public boolean isAllowMissingCloseMessage() + { + return _allowMissingCloseMessage; + } + + public void setAllowMissingCloseMessage(boolean allowMissingCloseMessage) + { + this._allowMissingCloseMessage = allowMissingCloseMessage; + } + + private int getApplicationBufferSize() + { + return getBufferSize(SSLSession::getApplicationBufferSize); + } + + private int getPacketBufferSize() + { + return getBufferSize(SSLSession::getPacketBufferSize); + } + + private int getBufferSize(ToIntFunction bufferSizeFn) + { + SSLSession hsSession = _sslEngine.getHandshakeSession(); + SSLSession session = _sslEngine.getSession(); + int size = bufferSizeFn.applyAsInt(session); + if (hsSession == null || hsSession == session) + return size; + int hsSize = bufferSizeFn.applyAsInt(hsSession); + return Math.max(hsSize, size); + } + + private void acquireEncryptedInput() + { + if (_encryptedInput == null) + _encryptedInput = _bufferPool.acquire(getPacketBufferSize(), _encryptedDirectBuffers); + } + + private void acquireEncryptedOutput() + { + if (_encryptedOutput == null) + _encryptedOutput = _bufferPool.acquire(getPacketBufferSize(), _encryptedDirectBuffers); + } + + private void releaseEncryptedInputBuffer() + { + if (_encryptedInput != null && !_encryptedInput.hasRemaining()) + { + _bufferPool.release(_encryptedInput); + _encryptedInput = null; + } + } + + protected void releaseDecryptedInputBuffer() + { + if (_decryptedInput != null && !_decryptedInput.hasRemaining()) + { + _bufferPool.release(_decryptedInput); + _decryptedInput = null; + } + } + + @Override + public void onOpen() + { + super.onOpen(); + getDecryptedEndPoint().getConnection().onOpen(); + } + + @Override + public void onClose() + { + _decryptedEndPoint.getConnection().onClose(); + super.onClose(); + } + + @Override + public void close() + { + getDecryptedEndPoint().getConnection().close(); + } + + @Override + public boolean onIdleExpired() + { + return getDecryptedEndPoint().getConnection().onIdleExpired(); + } + + @Override + public void onFillable() + { + // onFillable means that there are encrypted bytes ready to be filled. + // however we do not fill them here on this callback, but instead wakeup + // the decrypted readInterest and/or writeFlusher so that they will attempt + // to do the fill and/or flush again and these calls will do the actually + // filling. + + if (LOG.isDebugEnabled()) + LOG.debug("onFillable enter {}", _decryptedEndPoint); + + // We have received a close handshake, close the end point to send FIN. + if (_decryptedEndPoint.isInputShutdown()) + _decryptedEndPoint.close(); + + // wake up whoever is doing the fill or the flush so they can + // do all the filling, unwrapping, wrapping and flushing + _decryptedEndPoint.getFillInterest().fillable(); + + // If we are handshaking, then wake up any waiting write as well as it may have been blocked on the read + boolean runComplete = false; + synchronized(_decryptedEndPoint) + { + if (_decryptedEndPoint._flushRequiresFillToProgress) + { + _decryptedEndPoint._flushRequiresFillToProgress = false; + runComplete = true; + } + } + if (runComplete) + _runCompletWrite.run(); + + if (LOG.isDebugEnabled()) + LOG.debug("onFillable exit {}", _decryptedEndPoint); + } + + @Override + public void onFillInterestedFailed(Throwable cause) + { + // this means that the fill interest in encrypted bytes has failed. + // However we do not handle that here on this callback, but instead wakeup + // the decrypted readInterest and/or writeFlusher so that they will attempt + // to do the fill and/or flush again and these calls will do the actually + // handle the cause. + _decryptedEndPoint.getFillInterest().onFail(cause); + + boolean failFlusher = false; + synchronized(_decryptedEndPoint) + { + if (_decryptedEndPoint._flushRequiresFillToProgress) + { + _decryptedEndPoint._flushRequiresFillToProgress = false; + failFlusher = true; + } + } + if (failFlusher) + _decryptedEndPoint.getWriteFlusher().onFail(cause); + } + + protected SSLEngineResult wrap(SSLEngine sslEngine, ByteBuffer[] input, ByteBuffer output) throws SSLException + { + return sslEngine.wrap(input, output); + } + + protected SSLEngineResult unwrap(SSLEngine sslEngine, ByteBuffer input, ByteBuffer output) throws SSLException + { + // CVE-2021-28165 - Jetty #6072 + // https://github.com/eclipse/jetty.project/security/advisories/GHSA-26vr-8j45-3r4w + SSLEngineResult results = sslEngine.unwrap(input, output); + if ((results.getStatus() == SSLEngineResult.Status.BUFFER_UNDERFLOW || + results.getStatus() == SSLEngineResult.Status.OK && results.bytesConsumed() == 0 && results.bytesProduced() == 0) && + BufferUtil.space(input) == 0) + { + BufferUtil.clear(input); + throw new SSLHandshakeException("Encrypted buffer max length exceeded"); + } + return results; + } + + @Override + public String toString() + { + ByteBuffer b = _encryptedInput; + int ei=b==null?-1:b.remaining(); + b = _encryptedOutput; + int eo=b==null?-1:b.remaining(); + b = _decryptedInput; + int di=b==null?-1:b.remaining(); + + return String.format("SslConnection@%x{%s,eio=%d/%d,di=%d} -> %s", + hashCode(), + _sslEngine.getHandshakeStatus(), + ei,eo,di, + _decryptedEndPoint.getConnection()); + } + + public class DecryptedEndPoint extends AbstractEndPoint + { + private boolean _fillRequiresFlushToProgress; + private boolean _flushRequiresFillToProgress; + private boolean _cannotAcceptMoreAppDataToFlush; + private boolean _handshaken; + private boolean _underFlown; + + private final Callback _writeCallback = new Callback() + { + @Override + public void succeeded() + { + // This means that a write of encrypted data has completed. Writes are done + // only if there is a pending writeflusher or a read needed to write + // data. In either case the appropriate callback is passed on. + boolean fillable = false; + synchronized (DecryptedEndPoint.this) + { + if (LOG.isDebugEnabled()) + LOG.debug("write.complete {}", SslConnection.this.getEndPoint()); + + releaseEncryptedOutputBuffer(); + + _cannotAcceptMoreAppDataToFlush = false; + + if (_fillRequiresFlushToProgress) + { + _fillRequiresFlushToProgress = false; + fillable = true; + } + } + if (fillable) + getFillInterest().fillable(); + _runCompletWrite.run(); + } + + @Override + public void failed(final Throwable x) + { + // This means that a write of data has failed. Writes are done + // only if there is an active writeflusher or a read needed to write + // data. In either case the appropriate callback is passed on. + boolean fail_filler; + synchronized (DecryptedEndPoint.this) + { + if (LOG.isDebugEnabled()) + LOG.debug("write failed {}", SslConnection.this, x); + + BufferUtil.clear(_encryptedOutput); + releaseEncryptedOutputBuffer(); + + _cannotAcceptMoreAppDataToFlush = false; + fail_filler = _fillRequiresFlushToProgress; + if (_fillRequiresFlushToProgress) + _fillRequiresFlushToProgress = false; + } + + failedCallback(new Callback() + { + @Override + public void failed(Throwable x) + { + if (fail_filler) + getFillInterest().onFail(x); + getWriteFlusher().onFail(x); + } + }, x); + } + + @Override + public boolean isNonBlocking() + { + return getWriteFlusher().isCallbackNonBlocking(); + } + }; + + public DecryptedEndPoint() + { + // Disable idle timeout checking: no scheduler and -1 timeout for this instance. + super(null, getEndPoint().getLocalAddress(), getEndPoint().getRemoteAddress()); + super.setIdleTimeout(-1); + } + + @Override + public long getIdleTimeout() + { + return getEndPoint().getIdleTimeout(); + } + + @Override + public void setIdleTimeout(long idleTimeout) + { + getEndPoint().setIdleTimeout(idleTimeout); + } + + @Override + public boolean isOpen() + { + return getEndPoint().isOpen(); + } + + @Override + protected WriteFlusher getWriteFlusher() + { + return super.getWriteFlusher(); + } + + @Override + protected void onIncompleteFlush() + { + // This means that the decrypted endpoint write method was called and not + // all data could be wrapped. So either we need to write some encrypted data, + // OR if we are handshaking we need to read some encrypted data OR + // if neither then we should just try the flush again. + boolean try_again = false; + boolean write = false; + boolean need_fill_interest = false; + synchronized (DecryptedEndPoint.this) + { + if (LOG.isDebugEnabled()) + LOG.debug("onIncompleteFlush {}", SslConnection.this); + // If we have pending output data, + if (BufferUtil.hasContent(_encryptedOutput)) + { + // write it + _cannotAcceptMoreAppDataToFlush = true; + write = true; + } + // If we are handshaking and need to read, + else if (_sslEngine.getHandshakeStatus() == HandshakeStatus.NEED_UNWRAP) + { + // check if we are actually read blocked in order to write + _flushRequiresFillToProgress = true; + need_fill_interest = !SslConnection.this.isFillInterested(); + } + else + { + // We can get here because the WriteFlusher might not see progress + // when it has just flushed the encrypted data, but not consumed anymore + // of the application buffers. This is mostly avoided by another iteration + // within DecryptedEndPoint flush(), but I cannot convince myself that + // this is never ever the case. + try_again = true; + } + } + + if (write) + getEndPoint().write(_writeCallback, _encryptedOutput); + else if (need_fill_interest) + ensureFillInterested(); + else if (try_again) + { + // If the output is closed, + if (isOutputShutdown()) + { + // don't bother writing, just notify of close + getWriteFlusher().onClose(); + } + // Else, + else + { + // try to flush what is pending + // execute to avoid recursion + getExecutor().execute(_runCompletWrite); + } + } + } + + @Override + protected void needsFillInterest() throws IOException + { + // This means that the decrypted data consumer has called the fillInterested + // method on the DecryptedEndPoint, so we have to work out if there is + // decrypted data to be filled or what callbacks to setup to be told when there + // might be more encrypted data available to attempt another call to fill + boolean fillable; + boolean write = false; + synchronized (DecryptedEndPoint.this) + { + // Do we already have some app data, then app can fill now so return true + fillable = (BufferUtil.hasContent(_decryptedInput)) + // or if we have encryptedInput and have not underflowed yet, the it is worth trying a fill + || BufferUtil.hasContent(_encryptedInput) && !_underFlown; + + // If we have no encrypted data to decrypt OR we have some, but it is not enough + if (!fillable) + { + // We are not ready to read data + + // Are we actually write blocked? + if (_fillRequiresFlushToProgress) + { + // we must be blocked trying to write before we can read + + // Do we have data to write + if (BufferUtil.hasContent(_encryptedOutput)) + { + // write it + _cannotAcceptMoreAppDataToFlush = true; + write = true; + } + else + { + // we have already written the net data + // pretend we are readable so the wrap is done by next readable callback + _fillRequiresFlushToProgress = false; + fillable=true; + } + } + } + } + if (write) + getEndPoint().write(_writeCallback, _encryptedOutput); + else if (fillable) + getExecutor().execute(_runFillable); + else + ensureFillInterested(); + } + + @Override + public void setConnection(Connection connection) + { + if (connection instanceof AbstractConnection) + { + // This is an optimization to avoid that upper layer connections use small + // buffers and we need to copy decrypted data rather than decrypting in place. + AbstractConnection c = (AbstractConnection)connection; + int appBufferSize = getApplicationBufferSize(); + if (c.getInputBufferSize() < appBufferSize) + c.setInputBufferSize(appBufferSize); + } + super.setConnection(connection); + } + + public SslConnection getSslConnection() + { + return SslConnection.this; + } + + @Override + public int fill(ByteBuffer buffer) throws IOException + { + try + { + synchronized (this) + { + Throwable failure = null; + try + { + // Do we already have some decrypted data? + if (BufferUtil.hasContent(_decryptedInput)) + return BufferUtil.append(buffer,_decryptedInput); + + // We will need a network buffer + if (_encryptedInput == null) + _encryptedInput = _bufferPool.acquire(_sslEngine.getSession().getPacketBufferSize(), _encryptedDirectBuffers); + else + BufferUtil.compact(_encryptedInput); + + + // loop filling and unwrapping until we have something + while (true) + { + // We also need an app buffer, but can use the passed buffer if it is big enough + ByteBuffer app_in; + int appBufferSize = getApplicationBufferSize(); + + if (BufferUtil.space(buffer) > appBufferSize) + app_in = buffer; + else if (_decryptedInput == null) + app_in = _decryptedInput = _bufferPool.acquire(appBufferSize, _decryptedDirectBuffers); + else + app_in = _decryptedInput; + + acquireEncryptedInput(); + + // Let's try reading some encrypted data... even if we have some already. + int net_filled = getEndPoint().fill(_encryptedInput); + + if (net_filled > 0 && !_handshaken && isOutboundDone()) + throw new SSLHandshakeException("Closed during handshake"); + + decryption: while (true) + { + // Let's unwrap even if we have no net data because in that + // case we want to fall through to the handshake handling + int pos = BufferUtil.flipToFill(app_in); + SSLEngineResult unwrapResult; + try + { + unwrapResult = unwrap(_sslEngine, _encryptedInput, app_in); + } + finally + { + BufferUtil.flipToFlush(app_in, pos); + } + + if (LOG.isDebugEnabled()) + LOG.debug("unwrap net_filled={} {} encryptedBuffer={} unwrapBuffer={} appBuffer={}", + net_filled, + unwrapResult.toString().replace('\n',' '), + BufferUtil.toSummaryString(_encryptedInput), + BufferUtil.toDetailString(app_in), + BufferUtil.toDetailString(buffer)); + + HandshakeStatus handshakeStatus = _sslEngine.getHandshakeStatus(); + HandshakeStatus unwrapHandshakeStatus = unwrapResult.getHandshakeStatus(); + Status unwrapResultStatus = unwrapResult.getStatus(); + + // Extra check on unwrapResultStatus == OK with zero bytes consumed + // or produced is due to an SSL client on Android (see bug #454773). + _underFlown = unwrapResultStatus == Status.BUFFER_UNDERFLOW || + unwrapResultStatus == Status.OK && unwrapResult.bytesConsumed() == 0 && unwrapResult.bytesProduced() == 0; + + if (_underFlown) + { + if (net_filled < 0 && _sslEngine.getUseClientMode()) + closeInbound(); + if (net_filled <= 0) + return net_filled; + } + + switch (unwrapResultStatus) + { + case CLOSED: + { + switch (handshakeStatus) + { + case NOT_HANDSHAKING: + // We were not handshaking, so just tell the app we are closed + return -1; + case NEED_TASK: + _sslEngine.getDelegatedTask().run(); + continue; + case NEED_WRAP: + // We need to send some handshake data (probably the close handshake). + // We return -1 so that the application can drive the close by flushing + // or shutting down the output. + return -1; + case NEED_UNWRAP: + // We expected to read more, but we got closed. + // Return -1 to indicate to the application to drive the close. + return -1; + default: + throw new IllegalStateException(); + } + } + case BUFFER_OVERFLOW: + // It's possible that SSLSession.applicationBufferSize has been expanded + // by the SSLEngine implementation. Unwrapping a large encrypted buffer + // causes BUFFER_OVERFLOW because the (old) applicationBufferSize is + // too small. Release the decrypted input buffer so it will be re-acquired + // with the larger capacity. + // See also system property "jsse.SSLEngine.acceptLargeFragments". + if (BufferUtil.isEmpty(_decryptedInput) && appBufferSize < getApplicationBufferSize()) + { + releaseDecryptedInputBuffer(); + break decryption; + } + throw new IllegalStateException("Unexpected unwrap result " + unwrapResultStatus); + + case BUFFER_UNDERFLOW: + case OK: + { + if (unwrapHandshakeStatus == HandshakeStatus.FINISHED) + handshakeFinished(); + + // Check whether re-negotiation is allowed + if (!allowRenegotiate(handshakeStatus)) + return -1; + + // If bytes were produced, don't bother with the handshake status; + // pass the decrypted data to the application, which will perform + // another call to fill() or flush(). + if (unwrapResult.bytesProduced() > 0) + { + if (app_in == buffer) + return unwrapResult.bytesProduced(); + return BufferUtil.append(buffer,_decryptedInput); + } + + switch (handshakeStatus) + { + case NOT_HANDSHAKING: + { + if (_underFlown) + break decryption; + continue; + } + case NEED_TASK: + { + _sslEngine.getDelegatedTask().run(); + continue; + } + case NEED_WRAP: + { + // If we are called from flush() + // return to let it do the wrapping. + if (_flushRequiresFillToProgress) + return 0; + + _fillRequiresFlushToProgress = true; + flush(BufferUtil.EMPTY_BUFFER); + if (BufferUtil.isEmpty(_encryptedOutput)) + { + // The flush wrote all the encrypted bytes so continue to fill. + _fillRequiresFlushToProgress = false; + if (_underFlown) + break decryption; + continue; + } + else + { + // The flush did not complete, return from fill() + // and let the write completion mechanism to kick in. + return 0; + } + } + case NEED_UNWRAP: + { + if (_underFlown) + break decryption; + continue; + } + default: + { + throw new IllegalStateException(); + } + } + } + default: + { + throw new IllegalStateException(); + } + } + } + } + } + catch (SSLHandshakeException x) + { + notifyHandshakeFailed(_sslEngine, x); + failure = x; + throw x; + } + catch (SSLException x) + { + if (!_handshaken) + { + x = (SSLException)new SSLHandshakeException(x.getMessage()).initCause(x); + notifyHandshakeFailed(_sslEngine, x); + } + failure = x; + throw x; + } + catch (Throwable x) + { + failure = x; + throw x; + } + finally + { + // If we are handshaking, then wake up any waiting write as well as it may have been blocked on the read + if (_flushRequiresFillToProgress) + { + _flushRequiresFillToProgress = false; + getExecutor().execute(failure == null ? _runCompletWrite : new FailWrite(failure)); + } + + releaseEncryptedInputBuffer(); + releaseDecryptedInputBuffer(); + } + } + } + catch (Throwable x) + { + close(x); + if(x instanceof IOException) + throw (IOException) x; + throw new RuntimeIOException(x); + } + } + + private void handshakeFinished() + { + if (_handshaken) + { + if (LOG.isDebugEnabled()) + LOG.debug("Renegotiated {}", SslConnection.this); + if (_renegotiationLimit>0) + _renegotiationLimit--; + } + else + { + _handshaken = true; + if (LOG.isDebugEnabled()) + LOG.debug("{} handshake succeeded {}/{} {}", + _sslEngine.getUseClientMode() ? "client" : "resumed server", + _sslEngine.getSession().getProtocol(),_sslEngine.getSession().getCipherSuite(), + SslConnection.this); + notifyHandshakeSucceeded(_sslEngine); + } + } + + private boolean allowRenegotiate(HandshakeStatus handshakeStatus) + { + if (!_handshaken || handshakeStatus == HandshakeStatus.NOT_HANDSHAKING) + return true; + + if (!isRenegotiationAllowed()) + { + if (LOG.isDebugEnabled()) + LOG.debug("Renegotiation denied {}", SslConnection.this); + shutdownInput(); + return false; + } + + if (getRenegotiationLimit()==0) + { + if (LOG.isDebugEnabled()) + LOG.debug("Renegotiation limit exceeded {}", SslConnection.this); + shutdownInput(); + return false; + } + + return true; + } + + private void shutdownInput() + { + try + { + _sslEngine.closeInbound(); + } + catch (Throwable x) + { + LOG.ignore(x); + } + } + + private void closeInbound() throws SSLException + { + HandshakeStatus handshakeStatus = _sslEngine.getHandshakeStatus(); + try + { + _sslEngine.closeInbound(); + } + catch (SSLException x) + { + if (handshakeStatus == HandshakeStatus.NOT_HANDSHAKING && !isAllowMissingCloseMessage()) + throw x; + else + LOG.ignore(x); + } + catch (Throwable x) + { + LOG.ignore(x); + } + } + + @Override + public boolean flush(ByteBuffer... appOuts) throws IOException + { + // The contract for flush does not require that all appOuts bytes are written + // or even that any appOut bytes are written! If the connection is write block + // or busy handshaking, then zero bytes may be taken from appOuts and this method + // will return 0 (even if some handshake bytes were flushed and filled). + // it is the applications responsibility to call flush again - either in a busy loop + // or better yet by using EndPoint#write to do the flushing. + + if (LOG.isDebugEnabled()) + { + for (ByteBuffer b : appOuts) + LOG.debug("flush {} {}", BufferUtil.toHexSummary(b), SslConnection.this); + } + + try + { + synchronized (this) + { + try + { + if (_cannotAcceptMoreAppDataToFlush) + { + if (isOutboundDone()) + throw new EofException(new ClosedChannelException()); + return false; + } + + while (true) + { + int packetBufferSize = getPacketBufferSize(); + acquireEncryptedOutput(); + + // We call sslEngine.wrap to try to take bytes from appOuts + // buffers and encrypt them into the _encryptedOutput buffer. + BufferUtil.compact(_encryptedOutput); + int pos = BufferUtil.flipToFill(_encryptedOutput); + SSLEngineResult wrapResult; + try + { + wrapResult = wrap(_sslEngine, appOuts,_encryptedOutput); + } + finally + { + BufferUtil.flipToFlush(_encryptedOutput, pos); + } + if (LOG.isDebugEnabled()) + LOG.debug("wrap {} {}", wrapResult.toString().replace('\n',' '), SslConnection.this); + + Status wrapResultStatus = wrapResult.getStatus(); + + boolean allConsumed=true; + for (ByteBuffer b : appOuts) + if (BufferUtil.hasContent(b)) + allConsumed=false; + + // and deal with the results returned from the sslEngineWrap + switch (wrapResultStatus) + { + case CLOSED: + { + // The SSL engine has close, but there may be close handshake that needs to be written + if (BufferUtil.hasContent(_encryptedOutput)) + { + _cannotAcceptMoreAppDataToFlush = true; + getEndPoint().flush(_encryptedOutput); + getEndPoint().shutdownOutput(); + // If we failed to flush the close handshake then we will just pretend that + // the write has progressed normally and let a subsequent call to flush + // (or WriteFlusher#onIncompleteFlushed) to finish writing the close handshake. + // The caller will find out about the close on a subsequent flush or fill. + if (BufferUtil.hasContent(_encryptedOutput)) + return false; + } + // otherwise we have written, and the caller will close the underlying connection + else + { + getEndPoint().shutdownOutput(); + } + return allConsumed; + } + case BUFFER_UNDERFLOW: + { + throw new IllegalStateException(); + } + case BUFFER_OVERFLOW: + { + // It's possible that SSLSession.packetBufferSize has been expanded + // by the SSLEngine implementation. Wrapping a large application buffer + // causes BUFFER_OVERFLOW because the (old) packetBufferSize is + // too small. Release the encrypted output buffer so that it will + // be re-acquired with the larger capacity. + // See also system property "jsse.SSLEngine.acceptLargeFragments". + if (packetBufferSize < getPacketBufferSize()) + { + releaseEncryptedOutputBuffer(); + continue; + } + if (BufferUtil.isEmpty(_encryptedOutput)) + { + throw new IllegalStateException("Unexpected wrap result " + wrapResultStatus); + } + // fall-through default case to flush() + } + default: + { + if (LOG.isDebugEnabled()) + LOG.debug("wrap {} {} {}", wrapResultStatus, BufferUtil.toHexSummary(_encryptedOutput), SslConnection.this); + + if (wrapResult.getHandshakeStatus() == HandshakeStatus.FINISHED) + handshakeFinished(); + + HandshakeStatus handshakeStatus = _sslEngine.getHandshakeStatus(); + + // Check whether re-negotiation is allowed + if (!allowRenegotiate(handshakeStatus)) + { + getEndPoint().shutdownOutput(); + return allConsumed; + } + + // if we have net bytes, let's try to flush them + if (BufferUtil.hasContent(_encryptedOutput)) + if (!getEndPoint().flush(_encryptedOutput)) + getEndPoint().flush(_encryptedOutput); // one retry + + // But we also might have more to do for the handshaking state. + switch (handshakeStatus) + { + case NOT_HANDSHAKING: + // If we have not consumed all and had just finished handshaking, then we may + // have just flushed the last handshake in the encrypted buffers, so we should + // try again. + if (!allConsumed && wrapResult.getHandshakeStatus()==HandshakeStatus.FINISHED && BufferUtil.isEmpty(_encryptedOutput)) + continue; + + // Return true if we consumed all the bytes and encrypted are all flushed + return allConsumed && BufferUtil.isEmpty(_encryptedOutput); + + case NEED_TASK: + // run the task and continue + _sslEngine.getDelegatedTask().run(); + continue; + + case NEED_WRAP: + // Hey we just wrapped! Oh well who knows what the sslEngine is thinking, so continue and we will wrap again + continue; + + case NEED_UNWRAP: + // Ah we need to fill some data so we can write. + // So if we were not called from fill and the app is not reading anyway + if (!_fillRequiresFlushToProgress && !getFillInterest().isInterested()) + { + // Tell the onFillable method that there might be a write to complete + _flushRequiresFillToProgress = true; + fill(BufferUtil.EMPTY_BUFFER); + // Check if after the fill() we need to wrap again + if (_sslEngine.getHandshakeStatus() == HandshakeStatus.NEED_WRAP) + continue; + } + return allConsumed && BufferUtil.isEmpty(_encryptedOutput); + + case FINISHED: + throw new IllegalStateException(); + } + } + } + } + } + catch (SSLHandshakeException x) + { + notifyHandshakeFailed(_sslEngine, x); + throw x; + } + finally + { + releaseEncryptedOutputBuffer(); + } + } + } + catch (Throwable x) + { + close(x); + throw x; + } + } + + private void releaseEncryptedOutputBuffer() + { + if (!Thread.holdsLock(DecryptedEndPoint.this)) + throw new IllegalStateException(); + if (_encryptedOutput != null && !_encryptedOutput.hasRemaining()) + { + _bufferPool.release(_encryptedOutput); + _encryptedOutput = null; + } + } + + @Override + public void shutdownOutput() + { + try + { + boolean flush = false; + boolean close = false; + synchronized (_decryptedEndPoint) + { + boolean ishut = isInputShutdown(); + boolean oshut = isOutputShutdown(); + if (LOG.isDebugEnabled()) + LOG.debug("shutdownOutput: oshut={}, ishut={} {}", oshut, ishut, SslConnection.this); + + if (oshut) + return; + + if (!_closedOutbound) + { + _closedOutbound=true; // Only attempt this once + closeOutbound(); + flush = true; + } + + // TODO review close logic here + if (ishut) + close = true; + } + + if (flush) + flush(BufferUtil.EMPTY_BUFFER); // Send the TLS close message. + if (close) + getEndPoint().close(); + else + ensureFillInterested(); + } + catch (Throwable x) + { + LOG.ignore(x); + getEndPoint().close(); + } + } + + private void closeOutbound() + { + try + { + _sslEngine.closeOutbound(); + } + catch (Throwable x) + { + LOG.ignore(x); + } + } + + private void ensureFillInterested() + { + if (getFillInterest().isCallbackNonBlocking()) + { + SslConnection.this.tryFillInterested(_nonBlockingReadCallback); + } + else + { + SslConnection.this.tryFillInterested(); + } + } + + @Override + public boolean isOutputShutdown() + { + return isOutboundDone() || getEndPoint().isOutputShutdown(); + } + + private boolean isOutboundDone() + { + try + { + return _sslEngine.isOutboundDone(); + } + catch (Throwable x) + { + LOG.ignore(x); + return true; + } + } + + @Override + public void close() + { + // First send the TLS Close Alert, then the FIN. + shutdownOutput(); + getEndPoint().close(); + super.close(); + } + + protected void close(Throwable failure) + { + // First send the TLS Close Alert, then the FIN. + shutdownOutput(); + getEndPoint().close(); + super.close(failure); + } + + @Override + public Object getTransport() + { + return getEndPoint(); + } + + @Override + public boolean isInputShutdown() + { + return getEndPoint().isInputShutdown() || isInboundDone(); + } + + private boolean isInboundDone() + { + try + { + return _sslEngine.isInboundDone(); + } + catch (Throwable x) + { + LOG.ignore(x); + return true; + } + } + + private void notifyHandshakeSucceeded(SSLEngine sslEngine) + { + SslHandshakeListener.Event event = null; + for (SslHandshakeListener listener : handshakeListeners) + { + if (event == null) + event = new SslHandshakeListener.Event(sslEngine); + try + { + listener.handshakeSucceeded(event); + } + catch (Throwable x) + { + LOG.info("Exception while notifying listener " + listener, x); + } + } + } + + private void notifyHandshakeFailed(SSLEngine sslEngine, Throwable failure) + { + SslHandshakeListener.Event event = null; + for (SslHandshakeListener listener : handshakeListeners) + { + if (event == null) + event = new SslHandshakeListener.Event(sslEngine); + try + { + listener.handshakeFailed(event, failure); + } + catch (Throwable x) + { + LOG.info("Exception while notifying listener " + listener, x); + } + } + } + + @Override + public String toString() + { + return super.toString()+"->"+getEndPoint().toString(); + } + + private class FailWrite implements Runnable + { + private final Throwable failure; + + private FailWrite(Throwable failure) + { + this.failure = failure; + } + + @Override + public void run() + { + getWriteFlusher().onFail(failure); + } + } + } +} diff -Nru i2p-0.9.49/apps/ministreaming/java/build.xml i2p-0.9.50/apps/ministreaming/java/build.xml --- i2p-0.9.49/apps/ministreaming/java/build.xml 2021-02-17 19:22:19.000000000 +0000 +++ i2p-0.9.50/apps/ministreaming/java/build.xml 2021-05-19 12:11:56.000000000 +0000 @@ -84,7 +84,7 @@ - + @@ -193,7 +193,7 @@ - + @@ -209,7 +209,7 @@ - + diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/news/NewsManager.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/news/NewsManager.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/news/NewsManager.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/news/NewsManager.java 2021-05-19 12:11:56.000000000 +0000 @@ -20,6 +20,7 @@ import net.i2p.util.FileUtil; import net.i2p.util.Log; import net.i2p.util.SystemVersion; +import net.i2p.util.Translate; import net.i2p.util.TranslateReader; import org.cybergarage.xml.Node; @@ -48,6 +49,7 @@ public static final String APP_NAME = "news"; private static final String BUNDLE_NAME = "net.i2p.router.news.messages"; + private static final String WELCOME_AUTHOR = "I2P Development Team"; /** * @param args ignored @@ -209,6 +211,8 @@ if (!rv.isEmpty()) { //rv.get(0).updated = RFC3339Date.parse3339Date("2015-01-01"); rv.get(0).updated = _context.clock().now(); + // Tagged in initialNews.xml inside a comment + rv.get(0).authorName = Translate.getString(WELCOME_AUTHOR, _context, BUNDLE_NAME); } else { if (_log.shouldWarn()) _log.warn("failed to load initial news"); diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/update/ConsoleUpdateManager.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/update/ConsoleUpdateManager.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/update/ConsoleUpdateManager.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/update/ConsoleUpdateManager.java 2021-05-19 12:11:56.000000000 +0000 @@ -1678,6 +1678,11 @@ @Override public String toString() { + if (version.length() == 13) { + try { + return "Version " + version + " (" + DataHelper.formatTime(Long.parseLong(version)) + ')'; + } catch (NumberFormatException nfe) {} + } return "Version " + version; } } diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateRunner.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateRunner.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateRunner.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateRunner.java 2021-05-19 12:11:56.000000000 +0000 @@ -441,7 +441,7 @@ boolean wasRunning = false; File destDir = new SecureDirectory(appDir, appName); if (destDir.exists()) { - if (Boolean.valueOf(props.getProperty("install-only")).booleanValue()) { + if (Boolean.parseBoolean(props.getProperty("install-only"))) { to.delete(); statusDone("" + _t("Downloaded plugin is for new installs only, but the plugin is already installed", url) + ""); return; @@ -517,7 +517,7 @@ return; } // do we defer extraction and installation? - if (Boolean.valueOf(props.getProperty("router-restart-required")).booleanValue()) { + if (Boolean.parseBoolean(props.getProperty("router-restart-required"))) { // Yup! try { if(!FileUtil.copy(to, (new SecureFile( new SecureFile(appDir.getCanonicalPath() +"/" + appName +"/"+ ZIP).getCanonicalPath())) , true, true)) { @@ -548,7 +548,7 @@ } update = true; } else { - if (Boolean.valueOf(props.getProperty("update-only")).booleanValue()) { + if (Boolean.parseBoolean(props.getProperty("update-only"))) { to.delete(); statusDone("" + _t("Plugin is for upgrades only, but the plugin is not installed") + ". " + appName + ' ' + version + ""); return; @@ -569,7 +569,7 @@ _updated = true; to.delete(); // install != update. Changing the user's settings like this is probabbly a bad idea. - if (Boolean.valueOf( props.getProperty("dont-start-at-install")).booleanValue()) { + if (Boolean.parseBoolean( props.getProperty("dont-start-at-install"))) { statusDone("" + _t("Plugin {0} installed", appName + ' ' + version) + ""); if(!update) { Properties pluginProps = PluginStarter.pluginProperties(); diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/ConfigServiceHandler.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/ConfigServiceHandler.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/ConfigServiceHandler.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/ConfigServiceHandler.java 2021-05-19 12:11:56.000000000 +0000 @@ -389,7 +389,7 @@ } } else if (enable) { // already set to true, GraphicsEnvironment initialized, can't change it now - if (Boolean.valueOf(System.getProperty("java.awt.headless"))) { + if (Boolean.parseBoolean(System.getProperty("java.awt.headless"))) { addFormError(_t("Restart required to take effect")); } else { dtg = new net.i2p.desktopgui.Main(_context, mgr, null); diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/BanlistRenderer.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/BanlistRenderer.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/BanlistRenderer.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/BanlistRenderer.java 2021-05-19 12:11:56.000000000 +0000 @@ -56,6 +56,7 @@ buf.append(""); + String unban = _t("unban now"); for (Map.Entry e : entries.entrySet()) { Hash key = e.getKey(); Banlist.Entry entry = e.getValue(); @@ -82,8 +83,9 @@ buf.append(_t(entry.cause)); } if (!key.equals(Hash.FAKE_HASH)) { + // note: CSS hides anchor text buf.append(" [").append(_t("unban now")).append("]"); + .append("#unsh\" title=\"").append(unban).append("\">[").append(unban).append("]"); } buf.append("\n"); } diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigNetHelper.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigNetHelper.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigNetHelper.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigNetHelper.java 2021-05-19 12:11:56.000000000 +0000 @@ -41,9 +41,18 @@ /** @return host or "unknown" */ public String getUdpIP() { - String rv = _context.getProperty(UDPTransport.PROP_IP); - if (rv != null) - return rv; + String s = _context.getProperty(TransportUtil.SSU_IPV6_CONFIG); + String rv; + if (!"only".equals(s)) { + rv = _context.getProperty(UDPTransport.PROP_IP); + if (rv != null) + return rv; + } + if (!"false".equals(s)) { + rv = _context.getProperty(UDPTransport.PROP_IPV6); + if (rv != null) + return rv; + } RouterAddress addr = _context.router().getRouterInfo().getTargetAddress("SSU"); if (addr != null) { rv = addr.getHost(); @@ -349,7 +358,7 @@ StringBuilder buf = new StringBuilder(256); buf.append("\n"); boolean found = false; - for (int i = 100; i >= -5; i -= 5) { + for (int i = 90; i >= -5; i -= 5) { int val = i; if (i == -5) { if (found) diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigPeerHelper.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigPeerHelper.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigPeerHelper.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigPeerHelper.java 2021-05-19 12:11:56.000000000 +0000 @@ -5,6 +5,7 @@ import java.util.Collections; import java.util.List; +import net.i2p.data.Hash; import net.i2p.router.Blocklist; import net.i2p.router.web.HelperBase; import net.i2p.util.Addresses; @@ -133,6 +134,13 @@ } /** + * @since 0.9.50 + */ + public boolean isBanned(Hash h) { + return _context.banlist().isBanlisted(h); + } + + /** * Convert a (non-negative) two's complement IP to exactly 16 bytes * * @since IPv6, moved from Blocklist in 0.9.48 diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/HomeHelper.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/HomeHelper.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/HomeHelper.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/HomeHelper.java 2021-05-19 12:11:56.000000000 +0000 @@ -104,7 +104,7 @@ _x("Graphs") + S + _x("Visualize information about the router") + S + "/graphs" + S + I + "chart_line.png" + S + _x("I2P Technical Docs") + S + _x("Technical documentation") + S + "http://i2p-projekt.i2p/how" + S + I + "education.png" + S + _x("Trac Wiki") + S + S + "http://trac.i2p2.i2p/" + S + I + "trac_wiki.png" + S + - _x("I2P Bug Reports") + S + _x("Bug tracker") + S + "http://trac.i2p2.i2p/report/1" + S + I + "bug.png" + S + + _x("I2P Bug Reports") + S + _x("Bug tracker") + S + "http://git.idk.i2p/i2p-hackers/i2p.i2p/-/issues" + S + I + "bug.png" + S + "stats.i2p" + S + _x("I2P Network Statistics") + S + "http://stats.i2p/cgi-bin/dashboard.cgi" + S + I + "chart_bar.png" + S + ""; @@ -172,7 +172,7 @@ return ""; } StringBuilder buf = new StringBuilder(1380); - buf.append(topWrap(_t("Network Information and Developer Information"))); + buf.append(topWrap(_t("Network and Developer Information"))); buf.append(table); buf.append(bottomWrap); return buf.toString(); diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/NetDbRenderer.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/NetDbRenderer.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/NetDbRenderer.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/NetDbRenderer.java 2021-05-19 12:11:56.000000000 +0000 @@ -332,7 +332,10 @@ for (RouterAddress ra : ri.getAddresses()) { if (!"SSU".equals(ra.getTransportStyle())) continue; - if (ssucaps.equals(ra.getOption("caps"))) { + String racaps = ra.getOption("caps"); + if (racaps == null) + continue; + if (racaps.contains(ssucaps)) { if (skipped < toSkip) { skipped++; break; @@ -1003,12 +1006,15 @@ Collections.sort(laddrs, new RAComparator()); addrs = laddrs; } + boolean debug = _context.getBooleanProperty(HelperBase.PROP_ADVANCED); for (RouterAddress addr : addrs) { String style = addr.getTransportStyle(); buf.append("").append(DataHelper.stripHTML(style)).append(":"); - int cost = addr.getCost(); - if (!((style.equals("SSU") && cost == 5) || (style.equals("NTCP") && cost == 10))) - buf.append(" ").append(_t("cost")).append(": ").append("" + cost).append(" "); + if (debug) { + int cost = addr.getCost(); + if (!((style.equals("SSU") && cost == 5) || (style.equals("NTCP") && cost == 10))) + buf.append(" ").append(_t("cost")).append(": ").append("" + cost).append(" "); + } Map p = addr.getOptionsMap(); for (Map.Entry e : p.entrySet()) { String name = (String) e.getKey(); @@ -1056,10 +1062,21 @@ rv |= SSU; } String host = addr.getHost(); - if (host != null && host.contains(":")) + if (host != null && host.contains(":")) { rv |= IPV6; - + } else { + String caps = addr.getOption("caps"); + if (caps != null && caps.contains("6")) + rv |= IPV6; + } } + // map invalid values with "" in TNAMES + if (rv == 3) + rv = 2; + else if (rv == 7) + rv = 6; + else if (rv == 8) + rv = 0; return rv; } diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/PeerHelper.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/PeerHelper.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/PeerHelper.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/PeerHelper.java 2021-05-19 12:11:56.000000000 +0000 @@ -300,7 +300,7 @@ } } - StringBuilder buf = new StringBuilder(512); + StringBuilder buf = new StringBuilder(1024); buf.append("").append(_t("NTCP connections")).append(": ").append(peers.size()); buf.append(". ").append(_t("Limit")).append(": ").append(nt.getMaxConnections()); //buf.append(". ").append(_t("Timeout")).append(": ").append(DataHelper.formatDuration2(_pumper.getIdleTimeout())); @@ -463,7 +463,7 @@ int numPeers = 0; int numRTTPeers = 0; - StringBuilder buf = new StringBuilder(512); + StringBuilder buf = new StringBuilder(4096); buf.append("").append(_t("UDP connections")).append(": ").append(peers.size()); buf.append(". ").append(_t("Limit")).append(": ").append(ut.getMaxConnections()); //buf.append(". ").append(_t("Timeout")).append(": ").append(DataHelper.formatDuration2(_expireTimeout)); @@ -675,16 +675,14 @@ long dupRecv = peer.getPacketsReceivedDuplicate(); buf.append(""); - //buf.append(formatPct(sendLostPct)); - buf.append(resent); // + "/" + peer.getPacketsPeriodRetransmitted() + "/" + sent); - //buf.append(peer.getPacketRetransmissionRate()); - buf.append(""); + buf.append(dupRecv); + buf.append("" + - buf.append(""); - buf.append(dupRecv); //formatPct(recvDupPct)); - buf.append(""); + ""); + buf.append(resent); + buf.append("" + - buf.append("\n"); + "\n"); out.write(buf.toString()); buf.setLength(0); diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/ProfileOrganizerRenderer.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/ProfileOrganizerRenderer.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/ProfileOrganizerRenderer.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/ProfileOrganizerRenderer.java 2021-05-19 12:11:56.000000000 +0000 @@ -303,10 +303,12 @@ .append("Caps").append(":").append(_t("capabilities in the netDb, not used to determine profiles")) .append(""); buf.append(""); +/* buf.append(" ") .append("B").append(_t("SSU Testing")).append("") .append("C").append(_t("SSU Introducer")).append("") .append(" "); +*/ buf.append(" ") .append("f").append(_t("Floodfill")).append("") .append("H").append(_t("Hidden")).append("") diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryBarRenderer.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryBarRenderer.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryBarRenderer.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryBarRenderer.java 2021-05-19 12:11:56.000000000 +0000 @@ -33,7 +33,7 @@ class SummaryBarRenderer { static final String ALL_SECTIONS[] = - {"HelpAndFAQ", "I2PServices", "I2PInternals", "RouterInfo", "ShortRouterInfo", "AdvancedRouterInfo", "MemoryBar", "NetworkReachability", + {"HelpAndFAQ", "I2PServices", "I2PInternals", "I2PDiagnostics", "RouterInfo", "ShortRouterInfo", "AdvancedRouterInfo", "MemoryBar", "NetworkReachability", "UpdateStatus", "RestartStatus", "Peers", "PeersAdvanced", "FirewallAndReseedStatus", "Bandwidth", "BandwidthGraph", "Tunnels", "Congestion", "TunnelStatus", "Destinations", "NewsHeadings", "Advanced" }; static final Map SECTION_NAMES; @@ -42,7 +42,8 @@ Map aMap = new HashMap(); aMap.put("HelpAndFAQ", _x("Help & FAQ")); aMap.put("I2PServices", _x("I2P Services")); - aMap.put("I2PInternals", _x("I2P Internals")); + aMap.put("I2PInternals", _x("Configuration")); + aMap.put("I2PDiagnostics", _x("Diagnostics")); aMap.put("RouterInfo", _x("Router Information")); aMap.put("ShortRouterInfo", _x("Router Information (brief)")); aMap.put("AdvancedRouterInfo", _x("Router Information (advanced)")); @@ -96,6 +97,8 @@ buf.append(renderI2PServicesHTML()); else if ("I2PInternals".equals(section)) buf.append(renderI2PInternalsHTML()); + else if ("I2PDiagnostics".equals(section)) + buf.append(renderI2PDiagnosticsHTML()); else if ("Advanced".equals(section)) buf.append(renderAdvancedHTML()); else if ("RouterInfo".equals(section) || "General".equals(section)) // Backwards-compatibility @@ -169,7 +172,7 @@ .append("\n"); svcs.put(tx, rbuf.toString()); - tx = _t("Legal"); + tx = _t("Licenses"); rbuf.setLength(0); rbuf.append("\n"); svcs.put(tx, rbuf.toString()); - tx = _t("Reachability"); + tx = _t("Network"); rbuf.setLength(0); - rbuf.append("") - .append(nbsp(tx)) - .append("\n"); - svcs.put(tx, rbuf.toString()); - - tx = _t("Setup"); - rbuf.setLength(0); - rbuf.append("") .append(nbsp(tx)) .append("\n"); @@ -261,19 +255,27 @@ svcs.put(tx, rbuf.toString()); } - String url = getEepsiteURL(pm); - if (url != null) { + List urls = pm.getEepsiteURLs(); + if (urls != null) { String tx = _t("Web Server"); - rbuf.setLength(0); - rbuf.append("" + - "") - .append(nbsp(tx)) - .append("\n"); - svcs.put(tx, rbuf.toString()); + String txtt = _t("Local web Server"); + int sz = urls.size(); + if (sz > 1) + Collections.sort(urls); + for (int i = 0; i < sz; i++) { + String url = urls.get(i); + String txp = sz > 1 ? tx + ' ' + (i + 1) : tx; + rbuf.setLength(0); + rbuf.append("" + + "") + .append(nbsp(txp)) + .append("\n"); + svcs.put(txp, rbuf.toString()); + } } Map apps = NavHelper.getClientAppLinks(); @@ -333,7 +335,7 @@ buf.append("") - .append(_t("I2P Internals")) + .append(_t("Configuration")) .append("\n" + "\n"); @@ -352,11 +354,11 @@ svcs.put(tx, rbuf.toString()); } - if (!StatSummarizer.isDisabled(_context)) { - String tx = _t("Graphs"); + if (pm.isRegistered(PortMapper.SVC_I2PTUNNEL)) { + String tx = _t("Hidden Services Manager"); rbuf.setLength(0); - rbuf.append("") .append(nbsp(tx)) .append("\n"); @@ -372,18 +374,62 @@ .append("\n"); svcs.put(tx, rbuf.toString()); - if (pm.isRegistered(PortMapper.SVC_I2PTUNNEL)) { - tx = _t("Hidden Services Manager"); + tx = _t("Settings"); + rbuf.setLength(0); + rbuf.append("") + .append(nbsp(tx)) + .append("\n"); + svcs.put(tx, rbuf.toString()); + + tx = _t("Setup"); + rbuf.setLength(0); + rbuf.append("") + .append(nbsp(tx)) + .append("\n"); + svcs.put(tx, rbuf.toString()); + + for (String row : svcs.values()) { + buf.append(row); + } + buf.append("\n"); + return buf.toString(); + } + + + /** + * Renders html for section containing logging, peer information, non-configuration "Admin" elements. + * @since 0.9.50 separates config from non config elements in "I2P Internals" + */ + public String renderI2PDiagnosticsHTML() { + StringBuilder buf = new StringBuilder(512); + buf.append("") + .append(_t("Diagnostics")) + .append("\n" + + + "\n"); + + // Store all items in map so they are sorted by translated name, then output + Map svcs = new TreeMap(Collator.getInstance()); + StringBuilder rbuf = new StringBuilder(128); + + if (!StatSummarizer.isDisabled(_context)) { + String tx = _t("Graphs"); rbuf.setLength(0); - rbuf.append("") .append(nbsp(tx)) .append("\n"); svcs.put(tx, rbuf.toString()); } - tx = _t("Logs"); + String tx = _t("Logs"); rbuf.setLength(0); rbuf.append("") .append(_t("Network")) .append(": ") diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryHelper.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryHelper.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryHelper.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/helpers/SummaryHelper.java 2021-05-19 12:11:56.000000000 +0000 @@ -57,6 +57,7 @@ "FirewallAndReseedStatus" + S + "I2PServices" + S + "I2PInternals" + S + + "I2PDiagnostics" + S + "HelpAndFAQ" + S + "Peers" + S + "RestartStatus" + S + @@ -74,6 +75,7 @@ "FirewallAndReseedStatus" + S + "I2PServices" + S + "I2PInternals" + S + + "I2PDiagnostics" + S + "Advanced" + S + "Peers" + S + "RestartStatus" + S + diff -Nru i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/HostCheckHandler.java i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/HostCheckHandler.java --- i2p-0.9.49/apps/routerconsole/java/src/net/i2p/router/web/HostCheckHandler.java 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/java/src/net/i2p/router/web/HostCheckHandler.java 2021-05-19 12:11:56.000000000 +0000 @@ -106,7 +106,7 @@ int httpsPort = _portMapper.getPort(PortMapper.SVC_HTTPS_CONSOLE); if (httpsPort > 0 && httpRequest.getLocalPort() != httpsPort) { String redir = _context.getProperty(PROP_REDIRECT); - if (Boolean.valueOf(redir) || + if (Boolean.parseBoolean(redir) || (redir == null && "1".equals(httpRequest.getHeader("Upgrade-Insecure-Requests")))) { sendRedirect(httpsPort, httpRequest, httpResponse); baseRequest.setHandled(true); diff -Nru i2p-0.9.49/apps/routerconsole/jsp/configfamily.jsp i2p-0.9.50/apps/routerconsole/jsp/configfamily.jsp --- i2p-0.9.49/apps/routerconsole/jsp/configfamily.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/configfamily.jsp 2021-05-19 12:11:56.000000000 +0000 @@ -17,15 +17,16 @@ <%@include file="formhandler.jsi" %> <%=intl._t("Routers in the same family share a family key.")%> -<%=intl._t("To join an existing family, import the private key you exported from a router in the family.")%> -<%=intl._t("To start a new family, enter a family name.")%> - <% String family = familyHelper.getFamily(); if (family.length() <= 0) { // no family yet %> +<%=intl._t("To join an existing family, import the private key you exported from a router in the family.")%> +<%=intl._t("To start a new family, enter a family name.")%> + + @@ -57,10 +58,13 @@ <% } else { // family is configured + family = net.i2p.data.DataHelper.escapeHTML(family); String keypw = familyHelper.getKeyPW(); if (keypw.length() > 0) { // family is active %> +<%=intl._t("The current router family is {0}.", '"' + family + '"')%> + <%=intl._t("Export Family Key")%> diff -Nru i2p-0.9.49/apps/routerconsole/jsp/configpeer.jsp i2p-0.9.50/apps/routerconsole/jsp/configpeer.jsp --- i2p-0.9.49/apps/routerconsole/jsp/configpeer.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/configpeer.jsp 2021-05-19 12:11:56.000000000 +0000 @@ -15,8 +15,23 @@ <% String peer = ""; - if (request.getParameter("peer") != null) - peer = net.i2p.data.DataHelper.stripHTML(request.getParameter("peer")); // XSS + net.i2p.data.Hash peerHash = null; + boolean isBanned = false; + if (request.getParameter("peer") != null) { + // don't redisplay after POST, we don't do P-R-G + if (!"POST".equals(request.getMethod())) { + peer = net.i2p.data.DataHelper.stripHTML(request.getParameter("peer")); // XSS + if (peer.length() == 44) { + byte[] h = net.i2p.data.Base64.decode(peer); + if (h != null) { + try { + peerHash = net.i2p.data.Hash.create(h); + isBanned = peerhelper.isBanned(peerHash); + } catch (Exception e) {} + } + } + } + } %> @@ -25,16 +40,23 @@ <%=intl._t("Manual Peer Controls")%> - <%=intl._t("Router Hash")%>: + <%=intl._t("Router Hash")%>: <%=intl._t("Manually Ban / Unban a Peer")%> <%=intl._t("Banning will prevent the participation of this peer in tunnels you create.")%> +<% + if (peerHash == null || !isBanned) { + %> " /> +<% + } + if (peerHash == null || isBanned) { + %> " /> - <% if (! "".equals(peer)) { %> - - <% } %> +<% + } + %> <%=intl._t("Adjust Profile Bonuses")%> diff -Nru i2p-0.9.49/apps/routerconsole/jsp/error500.jsp i2p-0.9.50/apps/routerconsole/jsp/error500.jsp --- i2p-0.9.49/apps/routerconsole/jsp/error500.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/error500.jsp 2021-05-19 12:11:56.000000000 +0000 @@ -39,8 +39,8 @@ <% /* note to translators - both parameters are URLs */ %><%=intl._t("Please report bugs on {0} or {1}.", - "trac.i2p2.i2p", - "trac.i2p2.de")%> + "git.idk.i2p", + "i2pgit.org")%> <%=intl._t("Please include this information in bug reports")%>: <%=intl._t("Error Details")%> @@ -63,6 +63,7 @@ <%=intl._t("I2P Version and Running Environment")%> I2P version: <%=net.i2p.router.RouterVersion.FULL_VERSION%> +API version: <%=net.i2p.CoreVersion.PUBLISHED_VERSION%> Java version: <%=System.getProperty("java.vendor")%> <%=System.getProperty("java.version")%> (<%=System.getProperty("java.runtime.name")%> <%=System.getProperty("java.runtime.version")%>) diff -Nru i2p-0.9.49/apps/routerconsole/jsp/help-faq.jsi i2p-0.9.50/apps/routerconsole/jsp/help-faq.jsi --- i2p-0.9.49/apps/routerconsole/jsp/help-faq.jsi 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/help-faq.jsi 2021-05-19 12:11:56.000000000 +0000 @@ -23,8 +23,7 @@ <%=intl._t("You may wish to add one or two to your subscription list.")%> http://stats.i2p/cgi-bin/newhosts.txt -http://no.i2p/export/alive-hosts.txt -http://identiguy.i2p/hosts.txt +http://notbob.i2p/hosts.txt <%=intl._t("Note that subscribing to a hosts.txt service is an act of trust, as a malicious subscription could give you incorrect addresses, so be careful subscribing to lists from unknown sources.")%> diff -Nru i2p-0.9.49/apps/routerconsole/jsp/help.jsp i2p-0.9.50/apps/routerconsole/jsp/help.jsp --- i2p-0.9.49/apps/routerconsole/jsp/help.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/help.jsp 2021-05-19 12:11:56.000000000 +0000 @@ -1,5 +1,4 @@ <%@page contentType="text/html"%> -<%@page trimDirectiveWhitespaces="true"%> <%@page pageEncoding="UTF-8"%> @@ -12,9 +11,9 @@ <%=intl._t("Sidebar")%> -<%=intl._t("Reachability")%> +<%=intl._t("Network")%> <%=intl._t("FAQ")%> -<%=intl._t("Legal")%> +<%=intl._t("Licenses")%> <%=intl._t("Change Log")%> <%@include file="help.jsi" %> diff -Nru i2p-0.9.49/apps/routerconsole/jsp/help-reachability.jsi i2p-0.9.50/apps/routerconsole/jsp/help-reachability.jsi --- i2p-0.9.49/apps/routerconsole/jsp/help-reachability.jsi 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/help-reachability.jsi 2021-05-19 12:11:56.000000000 +0000 @@ -1,4 +1,4 @@ -<%=intl._t("Reachability Help")%> +<%=intl._t("Network Help")%> <%=intl._t("While I2P will work fine behind most firewalls, your speeds and network integration will generally improve if the I2P port is forwarded for both UDP and TCP.")%> <%=intl._t("If you think you have opened up your firewall and I2P still thinks you are firewalled, remember that you may have multiple firewalls, for example both software packages and external hardware routers.")%> diff -Nru i2p-0.9.49/apps/routerconsole/jsp/logs.jsp i2p-0.9.50/apps/routerconsole/jsp/logs.jsp --- i2p-0.9.49/apps/routerconsole/jsp/logs.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/logs.jsp 2021-05-19 12:11:56.000000000 +0000 @@ -16,8 +16,8 @@ <%=intl._t("Note that system information, log timestamps, and log messages may provide clues to your location; please review everything you include in a bug report.")%> <% /* note to translators - both parameters are URLs */ %><%=intl._t("Please report bugs on {0} or {1}.", - "trac.i2p2.i2p", - "trac.i2p2.de")%> + "git.idk.i2p", + "i2pgit.org")%> @@ -25,6 +25,7 @@ I2P version:<%=net.i2p.router.RouterVersion.FULL_VERSION%> +API version:<%=net.i2p.CoreVersion.PUBLISHED_VERSION%> Java version:<%=System.getProperty("java.vendor")%> <%=System.getProperty("java.version")%> (<%=System.getProperty("java.runtime.name")%> <%=System.getProperty("java.runtime.version")%>) diff -Nru i2p-0.9.49/apps/routerconsole/jsp/themes/console/dark/console.css i2p-0.9.50/apps/routerconsole/jsp/themes/console/dark/console.css --- i2p-0.9.49/apps/routerconsole/jsp/themes/console/dark/console.css 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/themes/console/dark/console.css 2021-05-19 12:11:56.000000000 +0000 @@ -263,6 +263,30 @@ padding: 0; } +.hostaddform { + display: inline-block; + width: 45%; + vertical-align: top; +} + +.hostadd { + min-height: 20%; + width: 100%; +} + +.unicodeicon { + font-size: 2rem; + vertical-align: middle; +} + +.hostaddaction { + background: transparent !important; + border: none !important; + padding-bottom: 15px !important; + padding-top: 0px !important; +} + + /* end proxy errors */ /* sidebar */ @@ -3131,6 +3155,7 @@ position: absolute; background: none !important; box-shadow: none !important; + line-height: normal; z-index: 999; } Binary files /tmp/tmpa2po8ksu/Y97QNf3n1h/i2p-0.9.49/apps/routerconsole/jsp/themes/console/dark/images/dropdown_active.png and /tmp/tmpa2po8ksu/gmqvkxeEbx/i2p-0.9.50/apps/routerconsole/jsp/themes/console/dark/images/dropdown_active.png differ diff -Nru i2p-0.9.49/apps/routerconsole/jsp/themes/console/light/console.css i2p-0.9.50/apps/routerconsole/jsp/themes/console/light/console.css --- i2p-0.9.49/apps/routerconsole/jsp/themes/console/light/console.css 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/themes/console/light/console.css 2021-05-19 12:11:57.000000000 +0000 @@ -1176,6 +1176,30 @@ box-shadow: none; } +.hostaddform { + display: inline-block; + width: 45%; + vertical-align: top; +} + +.hostadd { + min-height: 20%; + width: 100%; + background: #fafaff !important; +} + +.unicodeicon { + font-size: 2rem; + vertical-align: middle; +} + +.hostaddaction { + background: transparent !important; + border: none !important; + padding-bottom: 15px !important; + padding-top: 0px !important; +} + /* end proxy error messages */ /* console error messages */ @@ -1320,7 +1344,7 @@ #susidnsframe { margin: 0 0 -2px; - height: 100%; + min-height: 100vh !important; width: 100%; overflow: hidden; } @@ -1328,7 +1352,6 @@ .main#tunnelmgr { padding: 0 10px; min-width: 556px; - height: 150%; } #i2ptunnelframe { @@ -1807,8 +1830,8 @@ .mlabtable { width: 30%; + top: 150px; position: absolute; - top: 17%; font-size: 10pt !important; } @@ -2197,9 +2220,9 @@ .wizardnotice { position: absolute; - top: 75%; - left: 5%; + left: 75%; width: 22%; + top: 75%; } #bandwidthconfig .configtable tr:last-child td { @@ -2498,28 +2521,29 @@ #wizardheading { border: none; - width: 100%; padding: 2%; margin: auto; - top: 1%; + margin-left: 40%; + margin-top: -1%; font-size: xx-large; letter-spacing: 0.08em; word-spacing: 0.1em; color: #41465f; - position: absolute; + line-height: normal; background: none !important; box-shadow: none !important; } .clickableProgression { - color: #327bbf; + color: #327bbf; + margin-left: 47%; } #infodiv { position: absolute; - left: 32%; - width: 35%; - top: 50%; + left: 33%; + width: 31%; + top: 25%; box-shadow: inset 0 0 0 1px #fff; background: rgba(255,255,255,0.7); font-size: larger; @@ -2530,10 +2554,8 @@ } #bandwidthconfig.configtable.wizardtable { - width: 35%; - top: 17%; - left: 32%; - position: absolute; + width: 31%; + margin-left: 65%; background: none; font-size: 10pt !important; } @@ -2542,7 +2564,6 @@ bottom: 10%; right: 10%; width: max-content; - position: absolute; box-shadow: none !important; white-space: normal; background: none; @@ -2571,23 +2592,20 @@ } #xhr.notification { - width: 30%; - position: absolute; - left: 30%; - top: 38%; + width: 20%; + position: relative; + left: 70%; + top: 30%; font-size: larger; - background: #eef; - box-shadow: inset 0 0 0 1px #fff; + background-size: auto; } #xhr2.notification { - width: 20%; - position: absolute; - left: 70%; - top: 30%; + width: 20%; + position: relative; + left: 70%; + top: 30%; font-size: larger; - background: #eef; - background: linear-gradient(to right, #fafaff, #eef); background-size: auto 100%, 100% 100%; box-shadow: inset 0 0 0 1px #fff; } @@ -3418,7 +3436,6 @@ h3 { padding: 7px 5px 6px 7px; - margin: 12px 0 0 0; border-radius: 0 2px 2px 0; font-size: 11pt; letter-spacing: 0.08em; @@ -3768,7 +3785,7 @@ transition: ease box-shadow 0.05s; } -input.wizardbutton, button.wizardbutton { +input.wizardbuttons, button.wizardbuttons { font-size: large; } @@ -4146,6 +4163,7 @@ .routersummary .cancel { margin-top: 10px; + padding: 5px 7px 1px 24px !important; } /* Show text on context specific buttons (eg deferred shutdown) */ @@ -4156,13 +4174,17 @@ text-indent: 0; text-align: left; min-width: 0 !important; - padding: 5px 7px 1px 22px !important; text-transform: capitalize; } -.routersummary .cancel { - text-transform: capitalize; - padding: 5px 7px 1px 22px !important; +.routersummary .cancel[value="cancelShutdown"] { + background: url(/themes/console/images/buttons/no.png) center left 6px no-repeat, linear-gradient(to bottom, #fff, #efefff) !important; + background-size: 14px 14px, 100% 100% !important; +} + +.routersummary .cancel[value="cancelShutdown"]:hover, .routersummary .cancel[value="cancelShutdown"]:focus, .routersummary .cancel[value="cancelShutdown"]:active { + background: url(/themes/console/images/buttons/no.png) center left 6px no-repeat, linear-gradient(to bottom, #eee, #fff) !important; + background-size: 14px 14px, 100% 100% !important; } .routersummary .reload[value="restartImmediate"] { @@ -4799,9 +4821,7 @@ } div#wizlangsettings.wizard { - position: absolute; - left: 15%; - top: 50%; + margin-left: 40%; } #themesettings hr, #langsettings hr { @@ -4809,12 +4829,11 @@ } img.wizard.progress { + mix-blend-mode: multiply; position: absolute; - top: 6%; + top: 1%; left: 1%; - max-height: 10%; - max-width: 30%; - mix-blend-mode: multiply; + max-width: 40%; } .overlay { @@ -4834,20 +4853,23 @@ .wizardtext { width: 25%; - position: absolute; - top: 17%; - left: 5%; font-size: larger; + margin-top: -20%; + margin-left: 10%; +} + +.wizardbuttons { + margin-left: 10%; } #wizard { z-index: 0; - position: absolute; left: 0px; top: 0px; height: 100%; width: 100%; background-color: #f8f9fa; + text-align: start; } .langselect { /* containing box for lang selection */ @@ -4862,16 +4884,17 @@ float: left; margin-left: 15%; transition: transform 0.3s ease 0s; + } .wizardimg { - max-width: 75%; + max-width: 50%; max-height: 100%; margin: auto; mix-blend-mode: multiply; - position: absolute; - z-index: 0; - right: 0%; + margin-left: 40%; + margin-top: -10%; + position: relative; } .langselect:hover { @@ -5379,13 +5402,24 @@ margin-top: 10px; } -#netdboverview th, #netdblookup th { +#netdboverview th { + text-transform: uppercase; + font-size: 11pt !important; + letter-spacing: 0.08em; + word-spacing: 0.1em; + background: #f6f6ff url(/themes/console/images/buttons/floodfill.png) 8px center no-repeat !important; + background: url(/themes/console/images/buttons/floodfill.png) 8px center no-repeat, linear-gradient(to bottom, #fcfcff 50%, rgba(255,255,255,0.6) 50%, rgba(240,240,255,0.4)), linear-gradient(to right, #fcfcff 5%, rgba(231, 231, 255, 0.8) 25%) !important; + background-size: 18px 18px, 100% 100%, 100% 100% !important; + padding: 8px 5px 8px 32px; +} + +#netdblookup th { text-transform: uppercase; font-size: 11pt !important; letter-spacing: 0.08em; word-spacing: 0.1em; - background: #f6f6ff url(/themes/console/images/info/launch_browser.png) 8px center no-repeat !important; - background: url(/themes/console/images/info/launch_browser.png) 8px center no-repeat, linear-gradient(to bottom, #fcfcff 50%, rgba(255,255,255,0.6) 50%, rgba(240,240,255,0.4)), linear-gradient(to right, #fcfcff 5%, rgba(231, 231, 255, 0.8) 25%) !important; + background: #f6f6ff url(/themes/console/images/buttons/search.png) 8px center no-repeat !important; + background: url(/themes/console/images/buttons/search.png) 8px center no-repeat, linear-gradient(to bottom, #fcfcff 50%, rgba(255,255,255,0.6) 50%, rgba(240,240,255,0.4)), linear-gradient(to right, #fcfcff 5%, rgba(231, 231, 255, 0.8) 25%) !important; background-size: 18px 18px, 100% 100%, 100% 100% !important; padding: 8px 5px 8px 32px; } Binary files /tmp/tmpa2po8ksu/Y97QNf3n1h/i2p-0.9.49/apps/routerconsole/jsp/themes/console/light/images/dropdown_active.png and /tmp/tmpa2po8ksu/gmqvkxeEbx/i2p-0.9.50/apps/routerconsole/jsp/themes/console/light/images/dropdown_active.png differ diff -Nru i2p-0.9.49/apps/routerconsole/jsp/welcome.jsp i2p-0.9.50/apps/routerconsole/jsp/welcome.jsp --- i2p-0.9.49/apps/routerconsole/jsp/welcome.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/welcome.jsp 2021-05-19 12:11:57.000000000 +0000 @@ -111,9 +111,6 @@ <%-- needed for CSS: --%> <%-- needed for lang setting in css.jsi: --%> - -<%=uihelper._t("Select Language")%> - ⬤ ◯ @@ -122,6 +119,9 @@ ◯ ◯ + +<%=uihelper._t("Select Language")%> + @@ -143,9 +143,6 @@ } else if (ipg == 2) { // Overview of bandwidth test %> - -<%=intl._t("Bandwidth Test")%> - ◯ ⬤ @@ -154,6 +151,9 @@ ◯ ◯ + +<%=intl._t("Bandwidth Test")%> + <%=intl._t("Let's check your internet connection!")%> @@ -179,9 +179,6 @@ } else if (ipg == 3) { // Bandwidth test in progress (w/ AJAX) %> - -<%=intl._t("Bandwidth Test in Progress")%> - ◯ ◯ @@ -190,7 +187,10 @@ ◯ ◯ - + +<%=intl._t("Bandwidth Test in Progress")%> + + <%=intl._t("Javascript is disabled - wait 60 seconds for the bandwidth test to complete and then click Next")%> @@ -219,8 +219,6 @@ if (request.getParameter("skipbw") == null) { // don't display this if we skipped the test %> - -<%=intl._t("Bandwidth Test Results")%> ◯ ◯ @@ -229,6 +227,8 @@ ◯ ◯ + +<%=intl._t("Bandwidth Test Results")%> <%=intl._t("Test server location")%><%=wizhelper.getServerLocation()%> <%=intl._t("Completion status")%><%=wizhelper.getCompletionStatus()%> @@ -249,7 +249,6 @@ %> <%=intl._t("Bandwidth Configuration")%> - - - - -EeproxyFrom Python-I2P. - - - -The Eeproxy is run by the I2P router. The proxy is normally used for web browsers, as a means of accessing eepsites. - - - -The eeproxy is usually available at http://127.0.0.1:4444/. - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,91 +0,0 @@ - -User's Guide:i2p.BaseHTTPServer - Wikipedia - - - - - - - -User's Guide:i2p.BaseHTTPServerFrom Python-I2P. - - - -Emulates Python BaseHTTPServer module using I2P sockets. - - - - - Overview - - -The Python module is described at http://www.python.org/doc/current/lib/module-BaseHTTPServer.html - - -To get a server going, use: - - - ->>> from i2p import BaseHTTPServer ->>> BaseHTTPServer.test(). - - - - -Consult the documentation for function test() to change basic server settings, such as the session name. - - -A fully customizable example: - - - ->>> from i2p import BaseHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() - - - - - - Classes - - -class BaseHTTPRequestHandler - -Same interface as Python class BaseHTTPServer.BaseHTTPRequestHandler. - - -class HTTPServer - -Same interface as Python class BaseHTTPServer.HTTPServer. - - - - - - Functions - - -test(HandlerClass=BaseHTTPRequestHandler, ServerClass=HTTPServer, protocol='HTTP/1.0', session='mytestxxx.i2p') - -Test the HTTP request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single command -line argument is given, the argument is used instead as the SAM session name. - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.CGIHTTPServer.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.CGIHTTPServer.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.CGIHTTPServer.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.CGIHTTPServer.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,90 +0,0 @@ - -User's Guide:i2p.CGIHTTPServer - Wikipedia - - - - - - - -User's Guide:i2p.CGIHTTPServerFrom Python-I2P. - - - -Module i2p.CGIHTTPServer emulates the Python CGIHTTPServer module using I2P sockets. - - - - - Overview - - -The Python module is described at http://www.python.org/doc/current/lib/module-CGIHTTPServer.html - - -To get a server going, use: - - - ->>> from i2p import CGIHTTPServer ->>> CGIHTTPServer.test(). - - - - -Consult the documentation for function test() to change basic server settings, such as the session name. - - -A fully customizable example: - - - ->>> from i2p import BaseHTTPServer, CGIHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() - - - - - - Classes - - -class CGIHTTPRequestHandler - -Same interface as Python class CGIHTTPServer.CGIHTTPRequestHandler. - - - - - - Functions - - - -test(HandlerClass=CGIHTTPRequestHandler, -ServerClass=i2p.BaseHTTPServer.HTTPServer, -session='mytestxxx.i2p') - -Test the HTTP CGI request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single -command line argument is given, the argument is used instead as the SAM session -name. - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.eep.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.eep.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.eep.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.eep.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,53 +0,0 @@ - -User's Guide:i2p.eep - Wikipedia - - - - - - - -User's Guide:i2p.eepFrom Python-I2P. - - - -Module i2p.eep allows Python programs to access the Eeproxy. - - - -With this module, a program can easily download eepsites. - - - - Functions - - -urlopen(url, eepaddr='127.0.0.1:4444') - - - Like urllib2.urlopen(url), but only works for eep-sites. - Example: f = urlopen('http://duck.i2p/index.html') - - - -urlget(url, eepaddr='127.0.0.1:4444') - - - Get contents of an eepsite. - Example: urlget('http://duck.i2p/'). - - - - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,59 +0,0 @@ - -User's Guide:i2p - Wikipedia - - - - - - - -User's Guide:i2pFrom Python-I2P. - - - -Package i2p is a container package for more specific modules. - - - -It contains the following modules: - - - - - i2p.BaseHTTPServer (Emulate Python BaseHTTPServer module) - i2p.CGIHTTPServer (Emulate Python CGIHTTPServer module) - i2p.eep (Retrieve eepsites) - i2p.router (Manage the I2P router) - i2p.select (Emulate Python select module) - i2p.SimpleHTTPServer (Emulate Python SimpleHTTPServer module) - i2p.socket (Send and receive across the I2P network) - i2p.SocketServer (Emulate Python SocketServer module) - i2p.tunnel (Exchange data between I2P and regular sockets) - - - -class Error(Exception): - - - Base class for all I2P errors. - - - - -class RouterError(Error): - - - Could not connect to router. - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.router.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.router.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.router.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.router.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,85 +0,0 @@ - -User's Guide:i2p.router - Wikipedia - - - - - - - -User's Guide:i2p.routerFrom Python-I2P. - - - -Module i2p.router allows Python programs to control the I2P router. - - - - - Functions - - -check(dir=None) - - Checks whether a locally installed router is running. Does - nothing if successful, otherwise raises i2p.RouterError. - - An I2P installation is located by using find(dir). - The router.config file is parsed for 'router.adminPort'. - This port is queried to determine whether the router is - running. - - -find(dir=None) - - - Find the absolute path to a locally installed I2P router. - - An I2P installation is located by looking in the - dir argument given to the function, then in the environment - I2P, then in PATH. It looks for startRouter.sh or - startRouter.bat. Raises ValueError if an I2P installation - could not be located. - - -start(dir=None, hidden=False) - - Start a locally installed I2P router. Does nothing if - the router has already been started. - - An I2P installation is located by using find(dir). - - If hidden is True, do not show a terminal for the router. - - -stop(dir=None, force=False) - - Stop a locally installed I2P router, if it was started by - the current Python program. If force is True, stop the - router even if it was started by another process. Do nothing - if force is False and the router was started by another program. - - The file 'router.config' is located using the same search - process used for find(dir). It is parsed for - 'router.shutdownPassword' and 'router.adminPort'. The - router is shut down through the admin port. - - Raises i2p.RouterError if the I2P router is running but cannot - be stopped. You must uncomment the - 'router.shutdownPassword' line for this command to work. - - - - - - - - - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.select.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.select.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.select.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.select.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,60 +0,0 @@ - -User's Guide:i2p.select - Wikipedia - - - - - - - -User's Guide:i2p.selectFrom Python-I2P. - - - -Module i2p.select emulates the Python module select. - - - -With this module, a program can perform select and poll commands on traditional and I2P sockets. - - -poll() - - - Returns a polling object. Works on SAM sockets and Python sockets. - See select.poll() in the Python library for more information. - - - - -select(readlist, writelist, errlist, timeout=None) - - - Performs a select call. Works on SAM sockets and Python sockets. - See select.select() in the Python library for more information. - - - - -Polling flags - - - POLLIN = 1 - POLLOUT = 4 - POLLERR = 8 - POLLHUP = 16 - POLLNVAL = 32 - POLLPRI = 1 - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.SimpleHTTPServer.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.SimpleHTTPServer.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.SimpleHTTPServer.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.SimpleHTTPServer.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,88 +0,0 @@ - -User's Guide:i2p.SimpleHTTPServer - Wikipedia - - - - - - - -User's Guide:i2p.SimpleHTTPServerFrom Python-I2P. - - - -Emulates Python SimpleHTTPServer module using I2P sockets. - - - - - Overview - - -The Python module is described at http://www.python.org/doc/current/lib/module-SimpleHTTPServer.html - - -To get a server going, use: - - - ->>> from i2p import SimpleHTTPServer ->>> SimpleHTTPServer.test(). - - - - -Consult the documentation for function test() to change basic server settings, such as the session name. - - -A fully customizable example: - - - ->>> from i2p import BaseHTTPServer, SimpleHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() - - - - - - Classes - - -class SimpleHTTPRequestHandler - -Same interface as Python class SimpleHTTPServer.SimpleHTTPRequestHandler. - - - - - - Functions - - - -test(HandlerClass=SimpleHTTPRequestHandler, ServerClass= i2p.BaseHTTPServer.HTTPServer, session='mytestxxx.i2p') - -Test the HTTP simple request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single command -line argument is given, the argument is used instead as the SAM session name. - - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.socket.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.socket.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.socket.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.socket.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,376 +0,0 @@ - -User's Guide:i2p.socket - Wikipedia - - - - - - - -User's Guide:i2p.socketFrom Python-I2P. - - - -Module i2p.socket allows Python programs to access the SAM proxy. It emulates the Python module socket. - - - -With this module, a program can send stream data, datagrams, and raw packets across the I2P network. - - - - -Table of contents - -1 Sockets - - -2 Functions - - -3 Errors - - - -4 Constants - - - Sockets - - -class socket(session, type, samaddr='127.0.0.1:7656', **kwargs) - - Create a new socket. Argument session should be a session - name -- if the name has not yet been used, an I2P - Destination will be created for it, otherwise, the - existing Destination will be re-used. An empty session - string causes a transient session to be created. Argument - type is one of SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - I2P configuration keyword arguments: - - - in_depth - depth of incoming tunnel (default 2) - - out_depth - depth of outgoing tunnel (default 2) - - A single session may be shared by more than one socket, if - the sockets are the same type, and if the sockets are - created within the same Python process. The socket - objects are multithread-safe. - - Examples: - >>> a = i2p.socket('Alice', i2p.SOCK_STREAM) - >>> b = i2p.socket('Bob', i2p.SOCK_DGRAM, - in_depth=2, out_depth=5) - - The created object behaves identically to a socket from - module socket, with the following exceptions: - - * I2P Destinations are used as address arguments [1]. - * bind is a no-op: sockets are always bound. - * send* methods send all data and are non-blocking. - - A given session name can only be open in a single Python - program at a time. If you need to overcome this - limitation, consider patching I2P. - - [1]. Alternatively, a host name can be used as an address. - It will be resolved using hosts.txt. - - - - - For details on how to use socket objects, see - http://www.python.org/doc/current/lib/socket-objects.html - - - - See the examples directory for code examples. - - -The class socket defines the following properties: - - - - dest - Local I2P Destination of socket - session - Session name - type - Socket type: SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - - - -The class socket defines the following methods: - - -accept(self) - - Accept an incoming connection. The socket must be type SOCK_STREAM, and - listen() must be called prior to this command. The return value is (conn, - remotedest), where conn is a new socket object made for the connection, and - remotedest is the remote Destination from which the connection was made. - - Example: - - >>> from i2p import socket - >>> s = socket.socket('Alice', socket.SOCK_STREAM) - >>> s.listen(10) - - This prepares the server. Now accept an incoming connection: - - >>> c, remotedest = s.accept() - >>> c.send('hello world!') - - If accept() is called on a socket that is in non-blocking mode or has a - timeout, i2p.socket.BlockError or i2p.socket.Timeout may be raised. This - indicates that no incoming connection is currently available. - - - -bind(self, address) - - Does nothing. Provided for compatibility with the Python socket command - bind(), which binds a server to a port. - - -close(self) - - Closes the socket. It is an error to call any method other than recv() or - recvfrom() on a closed socket. For streams, the receive methods return data - that was received prior to the closing of the socket. For datagram and raw - sockets, the receive methods cannot be used on a closed socket. - - -connect(self, address) - - - Connect to a remote dest, identified in local SAM bridge's hosts file as host - 'address'. - - For example: - - >>> s.connect('duck.i2p') - - Alternatively, you can use a full base64 Destination: - Example: - - >>> s.connect('238797sdfh2k34kjh....AAAA') - - If connect() is called on a socket that is in non-blocking mode or has a - timeout, i2p.socket.BlockError or i2p.socket.Timeout may be raised. This - indicates that the connection is still being initiated. Use i2p.select.select() - to determine when the connection is ready. - - -connect_ex(self, address) - - Like connect(), but return any error that is raised. Returns None if no error - is raised. - - -getpeername(self) - - - Get the remote Destination associated with the socket. This is equivalent to - s.remotedest, and is provided for compatibility with the Python socket module. - - -getsockname(self) - - Get the local Destination associated with the socket. This is equivalent to - s.dest, and is provided for compatibility with the Python socket module. - - -gettimeout(self) - - Get the timeout value. - - - -listen(self, backlog) - - Listen for connections made to the socket. This method must be called before - accept(). The backlog argument specifies the maximum number of queued incoming - connections. - - -makefile(self, mode='r', bufsize=-1) - - Return a file object for the socket. See socket.makefile() in the Python - documentation for more information. - - -recv(self, bufsize, flags=0) - - - Receive string data from the socket. - - The maximum amount of data to be received is given by bufsize. If bufsize is - zero, this function returns an empty string immediately. If bufsize is nonzero, - this function blocks until at least one character is available for reading. If - the socket has been closed, an empty string is returned as an end of file - indicator. - - If recv() is called on a socket that is in non-blocking mode or has a timeout, - i2p.socket.BlockError or i2p.socket.Timeout will be raised if data is not - available within the given timeframe. - - For a datagram or raw socket, the first bufsize characters of the packet are - read, and the remainder of the packet is discarded. To read the entire packet, - use bufsize = -1. - - For datagram and raw sockets, the packet may originate from any Destination. - Use recvfrom() with datagrams to determine the Destination from which the - packet was received. - - The flags argument can be a bitwise OR of MSG_PEEK, MSG_WAITALL, and/or - MSG_DONTWAIT. MSG_PEEK indicates that any data read should not be removed from - the socket's incoming buffer. MSG_WAITALL indicates to wait for exactly bufsize - characters or an error. MSG_DONTWAIT indicates that the recv() command should - not block execution. - - -recvfrom(self, bufsize, flags=0) - - Like recv(), but returns a tuple (data, remoteaddr), where data is the string - data received, and remoteaddr is the remote Destination. - - -send(self, string, flags=0) - - Sends string data to a remote Destination. - - For a stream, connect() must be called prior to send(). Once close() is called, - no further data can be sent, and the stream cannot be re-opened. - - For datagram and raw sockets, connect() only specifies a Destination to which - packets are sent to. send() will then send a packet to the given Destination. - connect() can be used multiple times. - - The send() command never blocks execution. The flags argument is ignored. - - - -sendall(self, string, flags=0) - - Identical to send(). - - -sendto(self, string, flags, address) - - Send a packet to the given Destination. - - Only valid for datagram and raw sockets. The address argument should be either - a name from the hosts file, or a base64 Destination. - - The sendto() command never blocks execution. The flags argument is ignored. - - -setblocking(self, flag) - - - Set blocking or non-blocking mode for the socket. - - If flag is True, any method called on the socket will hang until the method has - completed. If flag is False, all methods will raise i2p.socket.BlockError() if - they cannot complete instantly. - - s.setblocking(False) is equivalent to s.settimeout(0); s.setblocking(True) is - equivalent to s.settimeout(None). - - -settimeout(self, value) - - Set a timeout for the socket. - - The value argument should be a timeout value in seconds, or None. None is - equivalent to an infinite timeout. - - A socket operation will raise a i2p.socket.Timeout if the operation cannot - complete within in the specified time limit. - - - - - - Functions - - -Functions defined in module i2p.socket: - - -resolve(host, samaddr='127.0.0.1:7656') - - - Resolve I2P host name --> I2P Destination. - Returns the same string if host is already a Destination. - - - - - - Errors - - -class Error(i2p.Error) - - Base class for all SAM errors. - - -class BlockError(Error) - - - Socket call would have blocked. - - -class ClosedError(Error) - - A command was used on a socket that closed gracefully. - - -class NetworkError(Error) - - - Network error occurred within I2P. - - The error object is a 2-tuple: (errtag, errdesc). - errtag is a SAM error string, - errdesc is a human readable error description. - - - - - - Constants - - -Socket types - - SOCK_STREAM = 1 - SOCK_DGRAM = 2 - SOCK_RAW = 3 - - - -Packet sizes - - MAX_DGRAM = 31744 # Maximum size for datagram packet - MAX_RAW = 32768 # Maximum size for raw packet - - -Flags for recv() - - MSG_DONTWAIT = 128 # Don't block - MSG_PEEK = 2 # Peek at incoming data - MSG_WAITALL = 64 # Wait for all data or error - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.SocketServer.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.SocketServer.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.SocketServer.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.SocketServer.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,50 +0,0 @@ - -User's Guide:i2p.SocketServer - Wikipedia - - - - - - - -User's Guide:i2p.SocketServerFrom Python-I2P. - - - -Emulates Python SocketServer module using I2P sockets. - - - -The Python module is described at http://www.python.org/doc/current/lib/module-SocketServer.html - - - - Classes - - - -BaseRequestHandler -BaseServer -DatagramRequestHandler -ForkingMixIn -ForkingTCPServer -ForkingUDPServer -StreamRequestHandler -TCPServer -ThreadingMixIn -ThreadingTCPServer -ThreadingUDPServer -UDPServer - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.tunnel.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.tunnel.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.tunnel.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.tunnel.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,124 +0,0 @@ - -User's Guide:i2p.tunnel - Wikipedia - - - - - - - -User's Guide:i2p.tunnelFrom Python-I2P. - - - -Module i2p.tunnel allows data to be exchanged between traditional TCP sockets and I2P sockets. - - - - - Tunnels - - -Tunnels allow stream sockets to be joined, so that connections to a listening socket are relayed to one or more sending sockets. This allows an ordinary web server to be exposed as an I2P Destination, or an I2P Destination to be bound as a local port, and so on. - - -class Tunnel(self, receive, make_send, nconnect=-1, timeout=60.0) - - A Tunnel relays connections from a 'receive' socket to one - or more 'send' sockets. The receive socket must be bound - and listening. For each incoming connection, a new send - socket is created by calling make_send(). Data is then - exchanged between the created streams until one socket is - closed. nconnect is the maximum number of simultaneous - connections (-1 for infinite), and timeout is the time that - a single connection can last for (None allows a connection - to last forever). - - Sockets must accept stream traffic and support the Python - socket interface. A separate daemonic thread is created to - manage the tunnel. For high performance, make_send() should - make a socket and connect in non-blocking mode (you should - catch and discard the i2p.socket.BlockError or socket.error - due to executing connect on a non-blocking socket). - - Security Note: - A firewall is needed to maintain the end user's anonymity. - An attacker could keep a tunnel socket open by pinging it - regularly. The accepted sockets from 'receive' must prevent - this by closing down eventually. - - Socket errors do not cause the Tunnel to shut down. - - - - -close() - - - Close all connections made for this tunnel. - - - - - - Tunnel Server - - -class TunnelServer(session, port, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) - - Tunnels incoming SAM streams --> localhost:port. - - nconnect and timeout are the maximum number of connections - and maximum time per connection. All other arguments are - passed to i2p.socket.socket(). This call blocks until the - tunnel is ready. - - - - -TunnelServer properties: - - - dest - I2P Destination of server. - session - Session name for server. - - - - - - Tunnel Client - - -class TunnelClient(session, port, dest, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) - - Derived from Tunnel. - Tunnels localhost:port --> I2P Destination dest. - - A session named 'session' is created locally, for purposes - of routing to 'dest'. nconnect and timeout are the maximum - number of connections and maximum time per connection. All - other arguments are passed to i2p.socket.socket(). This call - blocks until the tunnel is ready. - - - - - -TunnelClient properties: - - dest - Local Destination used for routing. - remotedest - Remote Destination. - session - Session name for local Destination. - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/index.html i2p-0.9.50/apps/sam/python/doc/guide/index.html --- i2p-0.9.49/apps/sam/python/doc/guide/index.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/index.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,82 +0,0 @@ - -Main Page - Wikipedia - - - - - - - -Main PageFrom Python-I2P. - - - -Python-I2P is a Python interface to I2P. - - - - - Quick Start - - -Install: - - - -python setup.py install - - - - -Use: - - - - ->>> from i2p import socket ->>> s = socket.socket('Alice', socket.SOCK_STREAM) ->>> s.connect('duck.i2p') ->>> s.send('GET / HTTP/1.0\r\n\r\n') ->>> s.recv(1000) -(HTTP response from duck.i2p) - - - - - -See the src/examples/ directory for more code examples. - - - - User's Guide - - -The following modules are available: - - - - - i2p (Container package) - i2p.BaseHTTPServer (Emulate Python BaseHTTPServer module) - i2p.CGIHTTPServer (Emulate Python CGIHTTPServer module) - i2p.eep (Retrieve eepsites) - i2p.router (Manage the I2P router) - i2p.select (Emulate Python select module) - i2p.SimpleHTTPServer (Emulate Python SimpleHTTPServer module) - i2p.socket (Send and receive across the I2P network) - i2p.SocketServer (Emulate Python SocketServer module) - i2p.tunnel (Exchange data between I2P and regular sockets) - - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/samproxy.html i2p-0.9.50/apps/sam/python/doc/guide/samproxy.html --- i2p-0.9.49/apps/sam/python/doc/guide/samproxy.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/samproxy.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,35 +0,0 @@ - -SAM proxy - Wikipedia - - - - - - - -SAM proxyFrom Python-I2P. - - - -A SAM proxy is run by the I2P router. The proxy allows streams, datagrams, and raw packets to be sent through the I2P network. A client application uses a telnet-like session to communicate with the proxy. In this way, the core features of the I2P library can be used by any language. - - - -The protocol used for SAM is described in SAM 1.0. - - -In practice, a SAM library is usually written, so that client applications do not need to use the low-level SAM commands. - - - - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/eeproxy.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/eeproxy.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/eeproxy.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/eeproxy.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,5 +0,0 @@ -Title: Eeproxy - -The '''Eeproxy''' is run by the I2P router. The proxy is normally used for web browsers, as a means of accessing eepsites. - -The eeproxy is usually available at http://127.0.0.1:4444/. diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,49 +0,0 @@ -Title: User's Guide:i2p.BaseHTTPServer - -Emulates Python BaseHTTPServer module using I2P sockets. - -== Overview == - -The Python module is described at http://www.python.org/doc/current/lib/module-BaseHTTPServer.html - -To get a server going, use: - - ->>> from i2p import BaseHTTPServer ->>> BaseHTTPServer.test(). - - -Consult the documentation for function test() to change basic server settings, such as the session name. - -A fully customizable example: - - ->>> from i2p import BaseHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() - - -== Classes == - -class '''BaseHTTPRequestHandler''' - -Same interface as Python class BaseHTTPServer.BaseHTTPRequestHandler. - -class '''HTTPServer''' - -Same interface as Python class BaseHTTPServer.HTTPServer. - - -== Functions == - -'''test'''(HandlerClass=BaseHTTPRequestHandler, ServerClass=HTTPServer, protocol='HTTP/1.0', session='mytestxxx.i2p') - -Test the HTTP request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single command -line argument is given, the argument is used instead as the SAM session name. - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.CGIHTTPServer.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.CGIHTTPServer.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.CGIHTTPServer.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.CGIHTTPServer.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,48 +0,0 @@ -Title: User's Guide:i2p.CGIHTTPServer - -Module i2p.CGIHTTPServer emulates the Python CGIHTTPServer module using I2P sockets. - -== Overview == - -The Python module is described at http://www.python.org/doc/current/lib/module-CGIHTTPServer.html - -To get a server going, use: - - ->>> from i2p import CGIHTTPServer ->>> CGIHTTPServer.test(). - - -Consult the documentation for function test() to change basic server settings, such as the session name. - -A fully customizable example: - - ->>> from i2p import BaseHTTPServer, CGIHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() - - -== Classes == - -class '''CGIHTTPRequestHandler''' - -Same interface as Python class CGIHTTPServer.CGIHTTPRequestHandler. - - -== Functions == - -'''test'''(HandlerClass=CGIHTTPRequestHandler, -ServerClass=i2p.BaseHTTPServer.HTTPServer, -session='mytestxxx.i2p') - -Test the HTTP CGI request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single -command line argument is given, the argument is used instead as the SAM session -name. - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.eep.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.eep.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.eep.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.eep.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,18 +0,0 @@ -Title: User's Guide:i2p.eep - -Module i2p.eep allows Python programs to access the [[Eeproxy]]. - -With this module, a program can easily download eepsites. - -== Functions == - -'''urlopen'''(url, eepaddr='127.0.0.1:4444') - - Like urllib2.urlopen(url), but only works for eep-sites. - Example: f = urlopen('http://duck.i2p/index.html') - -'''urlget'''(url, eepaddr='127.0.0.1:4444') - - Get contents of an eepsite. - Example: urlget('http://duck.i2p/'). - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.router.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.router.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.router.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.router.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,51 +0,0 @@ -Title: User's Guide:i2p.router - -Module i2p.router allows Python programs to control the I2P router. - -== Functions == - -'''check'''(dir=None) - - Checks whether a locally installed router is running. Does - nothing if successful, otherwise raises i2p.RouterError. - - An I2P installation is located by using find(dir). - The router.config file is parsed for 'router.adminPort'. - This port is queried to determine whether the router is - running. - -'''find'''(dir=None) - - Find the absolute path to a locally installed I2P router. - - An I2P installation is located by looking in the - dir argument given to the function, then in the environment - I2P, then in PATH. It looks for startRouter.sh or - startRouter.bat. Raises ValueError if an I2P installation - could not be located. - -'''start'''(dir=None, hidden=False) - - Start a locally installed I2P router. Does nothing if - the router has already been started. - - An I2P installation is located by using find(dir). - - If hidden is True, do not show a terminal for the router. - -'''stop'''(dir=None, force=False) - - Stop a locally installed I2P router, if it was started by - the current Python program. If force is True, stop the - router even if it was started by another process. Do nothing - if force is False and the router was started by another program. - - The file 'router.config' is located using the same search - process used for find(dir). It is parsed for - 'router.shutdownPassword' and 'router.adminPort'. The - router is shut down through the admin port. - - Raises i2p.RouterError if the I2P router is running but cannot - be stopped. You must uncomment the - 'router.shutdownPassword' line for this command to work. - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.sam.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.sam.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.sam.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.sam.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,202 +0,0 @@ -Title: User's Guide:i2p.sam - -Module i2p.sam allows Python programs to access the [[SAM proxy]]. - -With this module, a program can send stream data, datagrams, and raw packets across the I2P network. - -== Sockets == - -'''socket'''(session, type, samaddr='127.0.0.1:7656', **kwargs) - - Create a new socket. Argument session should be a session - name -- if the name has not yet been used, an I2P - Destination will be created for it, otherwise, the - existing Destination will be re-used. An empty session - string causes a transient session to be created. Argument - type is one of SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - I2P configuration keyword arguments: - - * in_depth - depth of incoming tunnel (default 2) - * out_depth - depth of outgoing tunnel (default 2) - - A single session may be shared by more than one socket, if - the sockets are the same type, and if the sockets are - created within the same Python process. The socket - objects are multithread-safe. - - Examples: - a = i2p.socket('Alice', i2p.SOCK_STREAM) - b = i2p.socket('Bob', i2p.SOCK_DGRAM, - in_depth=2, out_depth=5) - - The created object behaves identically to a socket from - module socket, with the following exceptions: - - * I2P Destinations are used as address arguments [1]. - * bind is a no-op: sockets are always bound. - * send* methods send all data and are non-blocking. - - A given session name can only be open in a single Python - program at a time. If you need to overcome this - limitation, consider patching I2P. - - [1]. Alternatively, a host name can be used as an address. - It will be resolved using hosts.txt. - - For details on how to use socket objects, see - http://www.python.org/doc/current/lib/socket-objects.html - - See the examples directory for code examples. - -'''socket()''' object properties: - - dest - Local I2P Destination of socket - session - Session name - type - Socket type: SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - -'''poll'''() - - Returns a polling object. Works on SAM sockets and Python sockets. - See [http://www.python.org/doc/current/lib/module-select.html select.poll()] in the Python library for more information. - - -'''resolve'''(host, samaddr='127.0.0.1:7656') - - Resolve I2P host name --> I2P Destination. - Returns the same string if host is already a Destination. - - -'''select'''(readlist, writelist, errlist, timeout=None) - - Performs a select call. Works on SAM sockets and Python sockets. - See [http://www.python.org/doc/current/lib/module-select.html select.select()] in the Python library for more information. - - -== Tunnels == - -Tunnels allow stream sockets to be joined, so that connections to a listening socket are relayed to one or more sending sockets. This allows an ordinary web server to be exposed as an I2P Destination, or an I2P Destination to be bound as a local port, and so on. - -class '''Tunnel'''(self, receive, make_send, nconnect=-1, timeout=60.0) - - A Tunnel relays connections from a 'receive' socket to one - or more 'send' sockets. The receive socket must be bound - and listening. For each incoming connection, a new send - socket is created by calling make_send(). Data is then - exchanged between the created streams until one socket is - closed. nconnect is the maximum number of simultaneous - connections (-1 for infinite), and timeout is the time that - a single connection can last for (None allows a connection - to last forever). - - Sockets must accept stream traffic and support the Python - socket interface. A separate daemonic thread is created to - manage the tunnel. For high performance, make_send() should - make a socket and connect in non-blocking mode (you should - catch and discard the sam.BlockError or socket.error due to - executing connect on a non-blocking socket). - - Security Note: - A firewall is needed to maintain the end user's anonymity. - An attacker could keep a tunnel socket open by pinging it - regularly. The accepted sockets from 'receive' must prevent - this by closing down eventually. - - Socket errors do not cause the Tunnel to shut down. - - -'''close'''() - - Close all connections made for this tunnel. - - -=== Tunnel Server === - -class '''TunnelServer'''(session, port, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) - - Tunnels incoming SAM streams --> localhost:port. - - nconnect and timeout are the maximum number of connections - and maximum time per connection. All other arguments are - passed to sam.socket(). This call blocks until the tunnel - is ready. - - -'''TunnelServer''' properties: - - dest - I2P Destination of server. - session - Session name for server. - - -=== Tunnel Client === - -class '''TunnelClient'''(session, port, dest, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) - - Derived from Tunnel. - Tunnels localhost:port --> I2P Destination dest. - - A session named 'session' is created locally, for purposes - of routing to 'dest'. nconnect and timeout are the maximum - number of connections and maximum time per connection. All - other arguments are passed to sam.socket(). This call blocks - until the tunnel is ready. - - -'''TunnelClient''' properties: - - dest - Local Destination used for routing. - remotedest - Remote Destination. - session - Session name for local Destination. - - -== Errors == - -class '''Error'''(i2p.Error) - - Base class for all SAM errors. - -class '''BlockError'''(Error) - - Socket call would have blocked. - -class '''ClosedError'''(Error) - - A command was used on a socket that closed gracefully. - -class '''NetworkError'''(Error) - - Network error occurred within I2P. - - The error object is a 2-tuple: (errtag, errdesc). - errtag is a SAM error string, - errdesc is a human readable error description. - - -== Constants == - -'''Socket types''' - - SOCK_STREAM = 1 - SOCK_DGRAM = 2 - SOCK_RAW = 3 - -'''Packet sizes''' - - MAX_DGRAM = 31744 # Maximum size for datagram packet - MAX_RAW = 32768 # Maximum size for raw packet - -'''Flags for recv()''' - - MSG_DONTWAIT = 128 # Don't block - MSG_PEEK = 2 # Peek at incoming data - MSG_WAITALL = 64 # Wait for all data or error - -'''Polling flags''' - - POLLIN = 1 - POLLOUT = 4 - POLLERR = 8 - POLLHUP = 16 - POLLNVAL = 32 - POLLPRI = 1 - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.select.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.select.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.select.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.select.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,27 +0,0 @@ -Title: User's Guide:i2p.select - -Module i2p.select emulates the Python module select. - -With this module, a program can perform select and poll commands on traditional and I2P sockets. - -'''poll'''() - - Returns a polling object. Works on SAM sockets and Python sockets. - See [http://www.python.org/doc/current/lib/module-select.html select.poll()] in the Python library for more information. - - -'''select'''(readlist, writelist, errlist, timeout=None) - - Performs a select call. Works on SAM sockets and Python sockets. - See [http://www.python.org/doc/current/lib/module-select.html select.select()] in the Python library for more information. - - -'''Polling flags''' - - POLLIN = 1 - POLLOUT = 4 - POLLERR = 8 - POLLHUP = 16 - POLLNVAL = 32 - POLLPRI = 1 - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.SimpleHTTPServer.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.SimpleHTTPServer.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.SimpleHTTPServer.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.SimpleHTTPServer.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,45 +0,0 @@ -Title: User's Guide:i2p.SimpleHTTPServer - -Emulates Python SimpleHTTPServer module using I2P sockets. - -== Overview == - -The Python module is described at http://www.python.org/doc/current/lib/module-SimpleHTTPServer.html - -To get a server going, use: - - ->>> from i2p import SimpleHTTPServer ->>> SimpleHTTPServer.test(). - - -Consult the documentation for function test() to change basic server settings, such as the session name. - -A fully customizable example: - - ->>> from i2p import BaseHTTPServer, SimpleHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() - - -== Classes == - -class '''SimpleHTTPRequestHandler''' - -Same interface as Python class SimpleHTTPServer.SimpleHTTPRequestHandler. - - -== Functions == - -'''test'''(HandlerClass=SimpleHTTPRequestHandler, ServerClass= i2p.BaseHTTPServer.HTTPServer, session='mytestxxx.i2p') - -Test the HTTP simple request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single command -line argument is given, the argument is used instead as the SAM session name. - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.SocketServer.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.SocketServer.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.SocketServer.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.SocketServer.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,22 +0,0 @@ -Title: User's Guide:i2p.SocketServer - -Emulates Python SocketServer module using I2P sockets. - -The Python module is described at http://www.python.org/doc/current/lib/module-SocketServer.html - -== Classes == - - -BaseRequestHandler -BaseServer -DatagramRequestHandler -ForkingMixIn -ForkingTCPServer -ForkingUDPServer -StreamRequestHandler -TCPServer -ThreadingMixIn -ThreadingTCPServer -ThreadingUDPServer -UDPServer - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.socket.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.socket.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.socket.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.socket.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,276 +0,0 @@ -Title: User's Guide:i2p.socket - -Module i2p.socket allows Python programs to access the [[SAM proxy]]. It emulates the Python module socket. - -With this module, a program can send stream data, datagrams, and raw packets across the I2P network. - -== Sockets == - -class '''socket'''(session, type, samaddr='127.0.0.1:7656', **kwargs) - - Create a new socket. Argument session should be a session - name -- if the name has not yet been used, an I2P - Destination will be created for it, otherwise, the - existing Destination will be re-used. An empty session - string causes a transient session to be created. Argument - type is one of SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - I2P configuration keyword arguments: - - - in_depth - depth of incoming tunnel (default 2) - - out_depth - depth of outgoing tunnel (default 2) - - A single session may be shared by more than one socket, if - the sockets are the same type, and if the sockets are - created within the same Python process. The socket - objects are multithread-safe. - - Examples: - >>> a = i2p.socket('Alice', i2p.SOCK_STREAM) - >>> b = i2p.socket('Bob', i2p.SOCK_DGRAM, - in_depth=2, out_depth=5) - - The created object behaves identically to a socket from - module socket, with the following exceptions: - - * I2P Destinations are used as address arguments [1]. - * bind is a no-op: sockets are always bound. - * send* methods send all data and are non-blocking. - - A given session name can only be open in a single Python - program at a time. If you need to overcome this - limitation, consider patching I2P. - - [1]. Alternatively, a host name can be used as an address. - It will be resolved using hosts.txt. - - For details on how to use socket objects, see - http://www.python.org/doc/current/lib/socket-objects.html - - See the examples directory for code examples. - -The class socket defines the following properties: - - dest - Local I2P Destination of socket - session - Session name - type - Socket type: SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - -The class socket defines the following methods: - -'''accept'''(self) - - Accept an incoming connection. The socket must be type SOCK_STREAM, and - listen() must be called prior to this command. The return value is (conn, - remotedest), where conn is a new socket object made for the connection, and - remotedest is the remote Destination from which the connection was made. - - Example: - - >>> from i2p import socket - >>> s = socket.socket('Alice', socket.SOCK_STREAM) - >>> s.listen(10) - - This prepares the server. Now accept an incoming connection: - - >>> c, remotedest = s.accept() - >>> c.send('hello world!') - - If accept() is called on a socket that is in non-blocking mode or has a - timeout, i2p.socket.BlockError or i2p.socket.Timeout may be raised. This - indicates that no incoming connection is currently available. - -'''bind'''(self, address) - - Does nothing. Provided for compatibility with the Python socket command - bind(), which binds a server to a port. - -'''close'''(self) - - Closes the socket. It is an error to call any method other than recv() or - recvfrom() on a closed socket. For streams, the receive methods return data - that was received prior to the closing of the socket. For datagram and raw - sockets, the receive methods cannot be used on a closed socket. - -'''connect'''(self, address) - - Connect to a remote dest, identified in local SAM bridge's hosts file as host - 'address'. - - For example: - - >>> s.connect('duck.i2p') - - Alternatively, you can use a full base64 Destination: - Example: - - >>> s.connect('238797sdfh2k34kjh....AAAA') - - If connect() is called on a socket that is in non-blocking mode or has a - timeout, i2p.socket.BlockError or i2p.socket.Timeout may be raised. This - indicates that the connection is still being initiated. Use i2p.select.select() - to determine when the connection is ready. - -'''connect_ex'''(self, address) - - Like connect(), but return any error that is raised. Returns None if no error - is raised. - -'''getpeername'''(self) - - Get the remote Destination associated with the socket. This is equivalent to - s.remotedest, and is provided for compatibility with the Python socket module. - -'''getsockname'''(self) - - Get the local Destination associated with the socket. This is equivalent to - s.dest, and is provided for compatibility with the Python socket module. - -'''gettimeout'''(self) - - Get the timeout value. - -'''listen'''(self, backlog) - - Listen for connections made to the socket. This method must be called before - accept(). The backlog argument specifies the maximum number of queued incoming - connections. - -'''makefile'''(self, mode='r', bufsize=-1) - - Return a file object for the socket. See socket.makefile() in the Python - documentation for more information. - -'''recv'''(self, bufsize, flags=0) - - Receive string data from the socket. - - The maximum amount of data to be received is given by bufsize. If bufsize is - zero, this function returns an empty string immediately. If bufsize is nonzero, - this function blocks until at least one character is available for reading. If - the socket has been closed, an empty string is returned as an end of file - indicator. - - If recv() is called on a socket that is in non-blocking mode or has a timeout, - i2p.socket.BlockError or i2p.socket.Timeout will be raised if data is not - available within the given timeframe. - - For a datagram or raw socket, the first bufsize characters of the packet are - read, and the remainder of the packet is discarded. To read the entire packet, - use bufsize = -1. - - For datagram and raw sockets, the packet may originate from any Destination. - Use recvfrom() with datagrams to determine the Destination from which the - packet was received. - - The flags argument can be a bitwise OR of MSG_PEEK, MSG_WAITALL, and/or - MSG_DONTWAIT. MSG_PEEK indicates that any data read should not be removed from - the socket's incoming buffer. MSG_WAITALL indicates to wait for exactly bufsize - characters or an error. MSG_DONTWAIT indicates that the recv() command should - not block execution. - -'''recvfrom'''(self, bufsize, flags=0) - - Like recv(), but returns a tuple (data, remoteaddr), where data is the string - data received, and remoteaddr is the remote Destination. - -'''send'''(self, string, flags=0) - - Sends string data to a remote Destination. - - For a stream, connect() must be called prior to send(). Once close() is called, - no further data can be sent, and the stream cannot be re-opened. - - For datagram and raw sockets, connect() only specifies a Destination to which - packets are sent to. send() will then send a packet to the given Destination. - connect() can be used multiple times. - - The send() command never blocks execution. The flags argument is ignored. - -'''sendall'''(self, string, flags=0) - - Identical to send(). - -'''sendto'''(self, string, flags, address) - - Send a packet to the given Destination. - - Only valid for datagram and raw sockets. The address argument should be either - a name from the hosts file, or a base64 Destination. - - The sendto() command never blocks execution. The flags argument is ignored. - -'''setblocking'''(self, flag) - - Set blocking or non-blocking mode for the socket. - - If flag is True, any method called on the socket will hang until the method has - completed. If flag is False, all methods will raise i2p.socket.BlockError() if - they cannot complete instantly. - - s.setblocking(False) is equivalent to s.settimeout(0); s.setblocking(True) is - equivalent to s.settimeout(None). - -'''settimeout'''(self, value) - - Set a timeout for the socket. - - The value argument should be a timeout value in seconds, or None. None is - equivalent to an infinite timeout. - - A socket operation will raise a i2p.socket.Timeout if the operation cannot - complete within in the specified time limit. - - -== Functions == - -Functions defined in module i2p.socket: - -'''resolve'''(host, samaddr='127.0.0.1:7656') - - Resolve I2P host name --> I2P Destination. - Returns the same string if host is already a Destination. - - -== Errors == - -class '''Error'''(i2p.Error) - - Base class for all SAM errors. - -class '''BlockError'''(Error) - - Socket call would have blocked. - -class '''ClosedError'''(Error) - - A command was used on a socket that closed gracefully. - -class '''NetworkError'''(Error) - - Network error occurred within I2P. - - The error object is a 2-tuple: (errtag, errdesc). - errtag is a SAM error string, - errdesc is a human readable error description. - - -== Constants == - -'''Socket types''' - - SOCK_STREAM = 1 - SOCK_DGRAM = 2 - SOCK_RAW = 3 - -'''Packet sizes''' - - MAX_DGRAM = 31744 # Maximum size for datagram packet - MAX_RAW = 32768 # Maximum size for raw packet - -'''Flags for recv()''' - - MSG_DONTWAIT = 128 # Don't block - MSG_PEEK = 2 # Peek at incoming data - MSG_WAITALL = 64 # Wait for all data or error - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.tunnel.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.tunnel.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.tunnel.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.tunnel.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,79 +0,0 @@ -Title: User's Guide:i2p.tunnel - -Module i2p.tunnel allows data to be exchanged between traditional TCP sockets and I2P sockets. - -== Tunnels == - -Tunnels allow stream sockets to be joined, so that connections to a listening socket are relayed to one or more sending sockets. This allows an ordinary web server to be exposed as an I2P Destination, or an I2P Destination to be bound as a local port, and so on. - -class '''Tunnel'''(self, receive, make_send, nconnect=-1, timeout=60.0) - - A Tunnel relays connections from a 'receive' socket to one - or more 'send' sockets. The receive socket must be bound - and listening. For each incoming connection, a new send - socket is created by calling make_send(). Data is then - exchanged between the created streams until one socket is - closed. nconnect is the maximum number of simultaneous - connections (-1 for infinite), and timeout is the time that - a single connection can last for (None allows a connection - to last forever). - - Sockets must accept stream traffic and support the Python - socket interface. A separate daemonic thread is created to - manage the tunnel. For high performance, make_send() should - make a socket and connect in non-blocking mode (you should - catch and discard the i2p.socket.BlockError or socket.error due to - executing connect on a non-blocking socket). - - Security Note: - A firewall is needed to maintain the end user's anonymity. - An attacker could keep a tunnel socket open by pinging it - regularly. The accepted sockets from 'receive' must prevent - this by closing down eventually. - - Socket errors do not cause the Tunnel to shut down. - - -'''close'''() - - Close all connections made for this tunnel. - - -=== Tunnel Server === - -class '''TunnelServer'''(session, port, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) - - Tunnels incoming SAM streams --> localhost:port. - - nconnect and timeout are the maximum number of connections - and maximum time per connection. All other arguments are - passed to i2p.socket.socket(). This call blocks until the - tunnel is ready. - - -'''TunnelServer''' properties: - - dest - I2P Destination of server. - session - Session name for server. - - -=== Tunnel Client === - -class '''TunnelClient'''(session, port, dest, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) - - Derived from Tunnel. - Tunnels localhost:port --> I2P Destination dest. - - A session named 'session' is created locally, for purposes - of routing to 'dest'. nconnect and timeout are the maximum - number of connections and maximum time per connection. All - other arguments are passed to i2p.socket.socket(). This call - blocks until the tunnel is ready. - - -'''TunnelClient''' properties: - - dest - Local Destination used for routing. - remotedest - Remote Destination. - session - Session name for local Destination. - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,26 +0,0 @@ -Title: User's Guide:i2p - -Package i2p is a container package for more specific modules. - -It contains the following modules: - - - [[:User's Guide:i2p.BaseHTTPServer|i2p.BaseHTTPServer]] (Emulate Python BaseHTTPServer module) - [[:User's Guide:i2p.CGIHTTPServer|i2p.CGIHTTPServer]] (Emulate Python CGIHTTPServer module) - [[:User's Guide:i2p.eep|i2p.eep]] (Retrieve eepsites) - [[:User's Guide:i2p.router|i2p.router]] (Manage the I2P router) - [[:User's Guide:i2p.select|i2p.select]] (Emulate Python select module) - [[:User's Guide:i2p.SimpleHTTPServer|i2p.SimpleHTTPServer]] (Emulate Python SimpleHTTPServer module) - [[:User's Guide:i2p.socket|i2p.socket]] (Send and receive across the I2P network) - [[:User's Guide:i2p.SocketServer|i2p.SocketServer]] (Emulate Python SocketServer module) - [[:User's Guide:i2p.tunnel|i2p.tunnel]] (Exchange data between I2P and regular sockets) - -class '''Error'''(Exception): - - Base class for all I2P errors. - - -class '''RouterError'''(Error): - - Could not connect to router. - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/index.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/index.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/index.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/index.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,41 +0,0 @@ -Title: Main Page - -'''Python-I2P''' is a Python interface to [http://www.i2p.net I2P]. - -== Quick Start == - -Install: - - -python setup.py install - - -Use: - - ->>> from i2p import socket ->>> s = socket.socket('Alice', socket.SOCK_STREAM) ->>> s.connect('duck.i2p') ->>> s.send('GET / HTTP/1.0\r\n\r\n') ->>> s.recv(1000) -(HTTP response from duck.i2p) - - -See the src/examples/ directory for more code examples. - -== User's Guide == - -The following modules are available: - - - [[:User's Guide:i2p|i2p]] (Container package) - [[:User's Guide:i2p.BaseHTTPServer|i2p.BaseHTTPServer]] (Emulate Python BaseHTTPServer module) - [[:User's Guide:i2p.CGIHTTPServer|i2p.CGIHTTPServer]] (Emulate Python CGIHTTPServer module) - [[:User's Guide:i2p.eep|i2p.eep]] (Retrieve eepsites) - [[:User's Guide:i2p.router|i2p.router]] (Manage the I2P router) - [[:User's Guide:i2p.select|i2p.select]] (Emulate Python select module) - [[:User's Guide:i2p.SimpleHTTPServer|i2p.SimpleHTTPServer]] (Emulate Python SimpleHTTPServer module) - [[:User's Guide:i2p.socket|i2p.socket]] (Send and receive across the I2P network) - [[:User's Guide:i2p.SocketServer|i2p.SocketServer]] (Emulate Python SocketServer module) - [[:User's Guide:i2p.tunnel|i2p.tunnel]] (Exchange data between I2P and regular sockets) - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/readme.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/readme.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/readme.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/readme.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,22 +0,0 @@ - -The documentation was created by using MediaWiki software. - -This directory houses the wiki text sources. - -Feel free to move to any other documentation system, if -it is efficient and easy to maintain. - -Do not use the Monobook skin, as it is Copyrighted. - -------------------------------------------------------- - -The documentation made by epydoc is pretty nice. - -Ideally, one could patch epydoc to use a more condensed -2-column format (where there are fewer pages, and it is -easier to read). - -With a little work on the output, epydoc could then be -used solely for documenting this project. - -Note that the docs produced by epydoc are huge. diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/samproxy.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/samproxy.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/samproxy.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/samproxy.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,7 +0,0 @@ -Title: SAM proxy - -A '''SAM proxy''' is run by the I2P router. The proxy allows streams, datagrams, and raw packets to be sent through the I2P network. A client application uses a telnet-like session to communicate with the proxy. In this way, the core features of the I2P library can be used by any language. - -The protocol used for SAM is described in [http://dev.i2p.net/pipermail/i2p/2004-July/000353.html SAM 1.0]. - -In practice, a ''SAM library'' is usually written, so that client applications do not need to use the low-level SAM commands. diff -Nru i2p-0.9.49/apps/sam/python/doc/index.html i2p-0.9.50/apps/sam/python/doc/index.html --- i2p-0.9.49/apps/sam/python/doc/index.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/index.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,21 +0,0 @@ - - - -Python-I2P - -Documentation: - - -User's Guide -Epydoc Documentation - - -How to build epydoc documentation: - - -Install epydoc. -Run makedoc.py in apps/sam/python/doc/epydoc/ - - - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/readme.txt i2p-0.9.50/apps/sam/python/readme.txt --- i2p-0.9.49/apps/sam/python/readme.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/readme.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,34 +0,0 @@ - ----------------------------------------- -Python-I2P v0.91 ----------------------------------------- - -Python-I2P is a Python interface to I2P. - -All files in this directory and subdirectories -have been placed in the public domain. - ----------------------------------------- -Quick Start ----------------------------------------- - -Install: - - python setup.py install - -Use: - - >>> from i2p import socket - >>> s = socket.socket('Alice', socket.SOCK_STREAM) - >>> s.connect('duck.i2p') - >>> s.send('GET / HTTP/1.0\r\n\r\n') - >>> s.recv(1000) - (Response from duck.i2p) - -See the src/examples/ directory for more code examples. - ----------------------------------------- -Full Start ----------------------------------------- - -See the docs directory for HTML documentation. diff -Nru i2p-0.9.49/apps/sam/python/setup.py i2p-0.9.50/apps/sam/python/setup.py --- i2p-0.9.49/apps/sam/python/setup.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/setup.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,15 +0,0 @@ -#! /usr/bin/env python - -from distutils.core import setup -import os, sys - -os.chdir('./src') - -setup(name="Python I2P API", - version="0.91", - description="Python Interface to I2P", - author="Connelly Barnes", - author_email="'Y29ubmVsbHliYXJuZXNAeWFob28uY29t\n'.decode('base64')", - url="http://www.i2p.net/", - packages=['i2p', 'i2p.pylib'], - ) diff -Nru i2p-0.9.49/apps/sam/python/src/examples/cgi_server.py i2p-0.9.50/apps/sam/python/src/examples/cgi_server.py --- i2p-0.9.49/apps/sam/python/src/examples/cgi_server.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/cgi_server.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,26 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# cgi_server.py: Simple CGI server -# ----------------------------------------------- - -myServerSession = "mytestxxx.i2p" - -from i2p import BaseHTTPServer, CGIHTTPServer - -class MyServer(BaseHTTPServer.HTTPServer): - pass - -class MyRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler): - pass - -def runServer(): - - httpd = MyServer(myServerSession, MyRequestHandler) - print "MyServer: local SAM session = %s" % myServerSession - print "MyServer: dest = %s" % httpd.socket.dest - httpd.serve_forever() - -if __name__ == '__main__': - runServer() - diff -Nru i2p-0.9.49/apps/sam/python/src/examples/datagram_noblock.py i2p-0.9.50/apps/sam/python/src/examples/datagram_noblock.py --- i2p-0.9.49/apps/sam/python/src/examples/datagram_noblock.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/datagram_noblock.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,21 +0,0 @@ -#! /usr/bin/env python - -# --------------------------------------------------- -# datagram_noblock.py: Non-blocking datagram server -# --------------------------------------------------- - -from i2p import socket -import time - -S = socket.socket('Eve', socket.SOCK_DGRAM) -print 'Serving at:', S.dest -S.setblocking(False) - -while True: - try: - (data, dest) = S.recvfrom(1000) # Read packet - print 'Got', data, 'from', dest - S.sendto('Hi client!', 0, dest) - except socket.BlockError: # No data available - pass - time.sleep(0.01) # Reduce CPU usage diff -Nru i2p-0.9.49/apps/sam/python/src/examples/datagram.py i2p-0.9.50/apps/sam/python/src/examples/datagram.py --- i2p-0.9.49/apps/sam/python/src/examples/datagram.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/datagram.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,18 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# datagram.py: Datagram client -# ----------------------------------------------- - -from i2p import socket - -print 'Sending a packet to yourserver.i2p...' - -dest = socket.resolve('yourserver.i2p') -S = socket.socket('Bob', socket.SOCK_DGRAM) -S.sendto('Hello packet', 0, dest) - -# Get packet up to 1000 bytes -- the rest is discarded. -(data, dest) = S.recvfrom(1000) - -print data diff -Nru i2p-0.9.49/apps/sam/python/src/examples/datagram_server.py i2p-0.9.50/apps/sam/python/src/examples/datagram_server.py --- i2p-0.9.49/apps/sam/python/src/examples/datagram_server.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/datagram_server.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,15 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# datagram_server.py: Datagram server -# ----------------------------------------------- - -from i2p import socket - -S = socket.socket('Eve', socket.SOCK_DGRAM) -print 'Serving at:', S.dest - -while True: - (data, dest) = S.recvfrom(1000) # Read packet - print 'Got', data, 'from', dest - S.sendto('Hi client!', 0, dest) diff -Nru i2p-0.9.49/apps/sam/python/src/examples/dos.py i2p-0.9.50/apps/sam/python/src/examples/dos.py --- i2p-0.9.49/apps/sam/python/src/examples/dos.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/dos.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,34 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# dos.py: Noneffective denial of service tool -# ----------------------------------------------- - -from i2p import socket -import threading, sys - -def dos_stream(dest): - """Perform a DOS attack on a stream server.""" - dest = socket.resolve(dest) - - # DOS code, runs in n separate threads. - def f(): - while True: - S = socket.socket(dest, socket.SOCK_STREAM) - S.connect(dest) - S.send('GET / HTTP/1.0\r\n\r\n') - S.close() - - # Start up the threads. - for i in range(128): - T = threading.Thread(target=f) - T.start() - -def syntax(): - print "Usage: python dos.py Destination" - -if __name__ == '__main__': - if len(sys.argv) == 2: - dos_stream(sys.argv[1]) - else: - syntax() diff -Nru i2p-0.9.49/apps/sam/python/src/examples/examples.txt i2p-0.9.50/apps/sam/python/src/examples/examples.txt --- i2p-0.9.49/apps/sam/python/src/examples/examples.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/examples.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,15 +0,0 @@ - -Examples: - -cgi_server.py - Example of CGIHTTPServer -datagram.py - Datagram client -datagram_noblock.py - Non-blocking datagram server -datagram_server.py - Blocking datagram server -dos.py - Denial of service tool -raw.py - Raw client -raw_noblock.py - Non-blocking raw server -raw_server.py - Raw server -stream.py - Stream client -stream_eepget.py - Get an eepsite using sockets -stream_noblock.py - Non-blocking stream server -stream_server.py - Blocking stream server diff -Nru i2p-0.9.49/apps/sam/python/src/examples/raw_noblock.py i2p-0.9.50/apps/sam/python/src/examples/raw_noblock.py --- i2p-0.9.49/apps/sam/python/src/examples/raw_noblock.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/raw_noblock.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,20 +0,0 @@ -#! /usr/bin/env python - -# --------------------------------------------------- -# raw_noblock.py: Non-blocking raw server -# --------------------------------------------------- - -from i2p import socket -import time - -S = socket.socket('Eve', socket.SOCK_RAW) -print 'Serving at:', S.dest -S.setblocking(False) - -while True: - try: - data = S.recv(1000) # Read packet - print 'Got', data - except socket.BlockError: # No data available - pass - time.sleep(0.01) # Reduce CPU usage \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/src/examples/raw.py i2p-0.9.50/apps/sam/python/src/examples/raw.py --- i2p-0.9.49/apps/sam/python/src/examples/raw.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/raw.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,11 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# raw.py: Raw client -# ----------------------------------------------- - -from i2p import socket - -dest = socket.resolve('yourserver.i2p') # Send to dest -S = socket.socket('Carol', socket.SOCK_RAW) -S.sendto('Hello packet', 0, dest) diff -Nru i2p-0.9.49/apps/sam/python/src/examples/raw_server.py i2p-0.9.50/apps/sam/python/src/examples/raw_server.py --- i2p-0.9.49/apps/sam/python/src/examples/raw_server.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/raw_server.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,14 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# raw_server.py: Raw server -# ----------------------------------------------- - -from i2p import socket - -S = socket.socket('Eve', socket.SOCK_RAW) -print 'Serving at:', S.dest - -while True: - data = S.recv(1000) # Read packet - print 'Got', data diff -Nru i2p-0.9.49/apps/sam/python/src/examples/stream_eepget.py i2p-0.9.50/apps/sam/python/src/examples/stream_eepget.py --- i2p-0.9.49/apps/sam/python/src/examples/stream_eepget.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/stream_eepget.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,18 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# stream_eepget.py: Get an eepsite using sockets -# ----------------------------------------------- - -from i2p import socket - -S = socket.socket('Alice', socket.SOCK_STREAM) -S.connect('duck.i2p') -S.send('GET / HTTP/1.0\r\n\r\n') # Send request -f = S.makefile() # File object - -while True: # Read header - line = f.readline().strip() # Read a line - if line == '': break # Content begins - -print f.read() # Read file object diff -Nru i2p-0.9.49/apps/sam/python/src/examples/stream_noblock.py i2p-0.9.50/apps/sam/python/src/examples/stream_noblock.py --- i2p-0.9.49/apps/sam/python/src/examples/stream_noblock.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/stream_noblock.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,40 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# stream_noblock.py: Non-blocking stream server -# ----------------------------------------------- - -import i2p -from i2p import socket -import thread, time - -S = socket.socket('Dave', socket.SOCK_STREAM) -S.listen(10) # Queue up to 10 connections -S.setblocking(False) # Non-blocking -print 'Serving at:', S.dest - -def handle_connection(C): - """Handle a single connection in a thread of its own.""" - try: - f = C.makefile() # File object - req = f.readline() # Read HTTP request - - s = 'Hello!' # String to send back - - f.write('HTTP/1.0 200 OK\r\nContent-Type: text/html' + - '\r\nContent-Length: ' + str(int(len(s))) + '\r\n\r\n' + s) - - f.close() # Close file - C.close() # Close connection - except socket.Error, e: - # Recover from socket errors - print 'Warning:', str(e) - -while True: - try: - (C, remotedest) = S.accept() # Get a connection - thread.start_new_thread(handle_connection, (C,)) - except socket.BlockError: - # Ignore 'command would have blocked' errors - pass - time.sleep(0.01) # Reduce CPU usage \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/src/examples/stream.py i2p-0.9.50/apps/sam/python/src/examples/stream.py --- i2p-0.9.49/apps/sam/python/src/examples/stream.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/stream.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,12 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# stream.py: Simple stream client -# ----------------------------------------------- - -from i2p import socket - -S = socket.socket('Alice', socket.SOCK_STREAM) -S.connect('duck.i2p') -S.send('GET / HTTP/1.0\r\n\r\n') # Send request -print S.recv(1000) # Read up to 1000 bytes diff -Nru i2p-0.9.49/apps/sam/python/src/examples/stream_server.py i2p-0.9.50/apps/sam/python/src/examples/stream_server.py --- i2p-0.9.49/apps/sam/python/src/examples/stream_server.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/stream_server.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,29 +0,0 @@ -#! /usr/bin/env python - -# ----------------------------------------------- -# stream_server.py: Simple stream server -# ----------------------------------------------- - -import i2p -from i2p import socket - -S = socket.socket('Dave', socket.SOCK_STREAM) -S.listen(10) # Queue up to 10 connections -print 'Serving at:', S.dest - -while True: - try: - (C, remotedest) = S.accept() # Get a connection - f = C.makefile() # File object - req = f.readline() # Read HTTP request - - s = 'Hello!' # String to send back - - f.write('HTTP/1.0 200 OK\r\nContent-Type: text/html' + - '\r\nContent-Length: ' + str(int(len(s))) + '\r\n\r\n' + s) - - f.close() # Close file - C.close() # Close connection - except socket.Error, e: - # Recover from socket errors - print 'Warning:', str(e) diff -Nru i2p-0.9.49/apps/sam/python/src/examples/win32/py2exe_demo.py i2p-0.9.50/apps/sam/python/src/examples/win32/py2exe_demo.py --- i2p-0.9.49/apps/sam/python/src/examples/win32/py2exe_demo.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/examples/win32/py2exe_demo.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,19 +0,0 @@ -#! /usr/bin/env python - -# -------------------------------------------------- -# py2exe_demo.py: Sample setup script for py2exe -# -------------------------------------------------- - -""" -Sample setup script for py2exe. - -Use 'python py2exe_demo.py install' to build an exe. - -A zip archive of the distribution is about 630 KB -(Delete _ssl.pyd to save space). -""" - -from distutils.core import setup -import py2exe - -setup(console=["../stream_eepget.py"]) diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/BaseHTTPServer.py i2p-0.9.50/apps/sam/python/src/i2p/BaseHTTPServer.py --- i2p-0.9.49/apps/sam/python/src/i2p/BaseHTTPServer.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/BaseHTTPServer.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,83 +0,0 @@ -#! /usr/bin/env python - -""" -Emulation of Python BaseHTTPServer module using I2P sockets. - -The Python module is described at -http://www.python.org/doc/current/lib/module-BaseHTTPServer.html - -To get a server going, use: - - >>> from i2p import BaseHTTPServer - >>> BaseHTTPServer.test(). - -Consult the documentation for function test() to change basic -server settings, such as the session name. - -A fully customizable example: - - >>> from i2p import BaseHTTPServer - >>> session = "mytestxxx.i2p" # SAM session name - >>> class MyServer(BaseHTTPServer.HTTPServer): pass - >>> class MyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): pass - >>> httpd = MyServer(session, MyRequestHandler) - >>> httpd.socket.dest - (Base64 Destination of server) - >>> httpd.serve_forever() - -""" - -# By aum. - -# Hack to keep Python from importing from current directory: -# Use pylib package, then use = signs instead of from x import y. -import pylib -BaseHTTPServer = pylib.BaseHTTPServer - -import sys -import i2p.SocketServer - -__version__ = "0.3" - -__all__ = ["HTTPServer", "BaseHTTPRequestHandler", "test"] - -DEFAULT_ERROR_MESSAGE = BaseHTTPServer.DEFAULT_ERROR_MESSAGE - -class HTTPServer(i2p.SocketServer.TCPServer, BaseHTTPServer.HTTPServer): - """ - Same interface as Python class - BaseHTTPServer.HTTPServer. - """ - -class BaseHTTPRequestHandler( - i2p.SocketServer.StreamRequestHandler, - BaseHTTPServer.BaseHTTPRequestHandler): - """ - Same interface as Python class - BaseHTTPServer.BaseHTTPRequestHandler. - """ - -def test(HandlerClass = BaseHTTPRequestHandler, - ServerClass = HTTPServer, protocol="HTTP/1.0", - session = "mytestxxx.i2p"): - """ - Test the HTTP request handler class. - - This runs an I2P TCP server under SAM session 'session'. - If a single command line argument is given, the argument is used - instead as the SAM session name. - """ - - if sys.argv[1:] and __name__ == '__main__': - session = sys.argv[1] - - HandlerClass.protocol_version = protocol - httpd = ServerClass(session, HandlerClass) - - print "Serving HTTP on", session, "..." - print "Destination follows:" - print httpd.socket.dest - httpd.serve_forever() - -if __name__ == '__main__': - test() diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/CGIHTTPServer.py i2p-0.9.50/apps/sam/python/src/i2p/CGIHTTPServer.py --- i2p-0.9.49/apps/sam/python/src/i2p/CGIHTTPServer.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/CGIHTTPServer.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,69 +0,0 @@ -#! /usr/bin/env python - -""" -Emulation of Python CGIHTTPServer module using I2P sockets. - -The Python module is described at -http://www.python.org/doc/current/lib/module-CGIHTTPServer.html - -To get a server going, use: - - >>> from i2p import CGIHTTPServer - >>> CGIHTTPServer.test(). - -Consult the documentation for function test() to change basic -server settings, such as the session name. - -A fully customizable example: - - >>> from i2p import BaseHTTPServer, CGIHTTPServer - >>> session = "mytestxxx.i2p" # SAM session name - >>> class MyServer(BaseHTTPServer.HTTPServer): pass - >>> class MyRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler): pass - >>> httpd = MyServer(session, MyRequestHandler) - >>> httpd.socket.dest - (Base64 Destination of server) - >>> httpd.serve_forever() - -""" - -# By aum. -__all__ = ["CGIHTTPRequestHandler", "test"] - -# Hack to keep Python from importing from current directory: -# Use pylib package, then use = signs instead of from x import y. -import pylib -CGIHTTPServer = pylib.CGIHTTPServer -nobody_uid = CGIHTTPServer.nobody_uid -executable = CGIHTTPServer.executable - -import sys -import i2p.BaseHTTPServer -import i2p.SimpleHTTPServer - -HTTPServer = i2p.BaseHTTPServer.HTTPServer -class CGIHTTPRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler): - """ - Same interface as Python class - CGIHTTPServer.CGIHTTPRequestHandler. - """ - -def test(HandlerClass = CGIHTTPRequestHandler, - ServerClass = i2p.BaseHTTPServer.HTTPServer, - session = "mytestxxx.i2p"): - """ - Test the HTTP CGI request handler class. - - This runs an I2P TCP server under SAM session 'session'. - If a single command line argument is given, the argument is used - instead as the SAM session name. - """ - if sys.argv[1:] and __name__ == '__main__': - session = sys.argv[1] - - i2p.SimpleHTTPServer.test(HandlerClass, ServerClass, - session=session) - -if __name__ == '__main__': - test() - diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/eep.py i2p-0.9.50/apps/sam/python/src/i2p/eep.py --- i2p-0.9.49/apps/sam/python/src/i2p/eep.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/eep.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,46 +0,0 @@ - -# ------------------------------------------------------------- -# eep.py: Eeproxy access module -# ------------------------------------------------------------- - -""" -Eeproxy access module -""" - -import urllib2 - -eepaddr = '127.0.0.1:4444' # Default port for eeproxy - -# -------------------------------------------------- -# Functions -# -------------------------------------------------- - -def urlopen(url, eepaddr=eepaddr): - """Like urllib2.urlopen(url), but only works for eep-sites. - Example: f = urlopen('http://duck.i2p/index.html')""" - if url.find('http://') != 0: url = 'http://' + url - - # Handle I2P Destination - if len(url) >= 256: - suffix = url[len('http://'):] - if suffix[:4] != 'i2p/': url = 'http://i2p/' + suffix - - # Add trailing slash - if url.find('/', len('http://')) < 0: url = url + '/' - - # Remove http:// and trailing slash from eepaddr. - if eepaddr.find('http://') == 0: eepaddr = eepaddr[len('http://'):] - eepaddr = eepaddr.rstrip('/') - - proxy = urllib2.ProxyHandler( \ - {'http': 'http://' + eepaddr}) - opener = urllib2.build_opener(proxy, urllib2.HTTPHandler) - return opener.open(url) - -def urlget(url, eepaddr=eepaddr): - """Get contents of an eepsite. - Example: urlget('http://duck.i2p/').""" - f = urlopen(url, eepaddr=eepaddr) - ans = f.read() - f.close() - return ans diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/__init__.py i2p-0.9.50/apps/sam/python/src/i2p/__init__.py --- i2p-0.9.49/apps/sam/python/src/i2p/__init__.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/__init__.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,22 +0,0 @@ -""" -i2p -- I2P Python interface -""" - -__all__ = [ - 'BaseHTTPServer', - 'CGIHTTPServer', - 'eep', - 'router', - 'select', - 'SimpleHTTPServer', - 'socket', - 'SocketServer', - 'tunnel', -] - -class Error(Exception): - """Base class for all I2P errors.""" - -class RouterError(Error): - """Could not connect to router.""" - diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/pylib/__init__.py i2p-0.9.50/apps/sam/python/src/i2p/pylib/__init__.py --- i2p-0.9.49/apps/sam/python/src/i2p/pylib/__init__.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/pylib/__init__.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,17 +0,0 @@ - -# ------------------------------------------------ -# Hack to import the Python library modules -# when names conflict in our package. -# ------------------------------------------------ - -import sys -sys.path.reverse() - -import socket -import select -import BaseHTTPServer -import SocketServer -import CGIHTTPServer -import SimpleHTTPServer - -sys.path.reverse() diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/router.py i2p-0.9.50/apps/sam/python/src/i2p/router.py --- i2p-0.9.49/apps/sam/python/src/i2p/router.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/router.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,185 +0,0 @@ - -# ------------------------------------------------------------- -# router.py: Router control module -# ------------------------------------------------------------- - -""" -Router control module -""" - -import i2p -import i2p.socket -import i2p.eep -from i2p.pylib import socket as pysocket # Import Python socket - -import os, sys -import os.path -import time -import threading -import urllib2 - -check_addrlist = [i2p.socket.samaddr, i2p.eep.eepaddr] - -router_config = 'router.config' # Router config filename - -# True if our Python program started the router -our_router = False -our_router_lock = threading.Lock() - - -def find(dir=None): - """Find the absolute path to a locally installed I2P router. - - An I2P installation is located by looking in the - the dir argument given to the function, then in the - environment I2P, then in PATH. It looks for startRouter.sh - or startRouter.bat. Raises ValueError if an I2P installation - could not be located. - """ - sep = os.pathsep # Path separator - L = [] - if dir != None and dir != '': L += dir.split(sep) - if 'I2P' in os.environ: L += os.environ['I2P'].split(sep) - if 'PATH' in os.environ: L += os.environ['PATH'].split(sep) - for dirname in L: - filename = os.path.join(dirname, 'startRouter.bat') - if os.path.exists(filename): - return dirname - filename = os.path.join(dirname, 'startRouter.sh') - if os.path.exists(filename): - return dirname - raise ValueError('I2P installation not found') - - -def check(dir=None): - """Checks whether a locally installed router is running. Does - nothing if successful, otherwise raises i2p.RouterError. - - An I2P installation is located by using find(dir). - The router.config file is parsed for 'router.adminPort'. - This port is queried to determine whether the router is - running. - """ - config = _parse_config(os.path.join(find(dir), router_config)) - port = config.get('router.adminPort', '') - try: - port = int(port) - except: - raise ValueError('router.adminPort missing or bad in ' + - router_config) - - try: - s = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_STREAM) - s.connect(('127.0.0.1', port)) - s.close() - except pysocket.error: - raise i2p.RouterError('could not contact 127.0.0.1:' + str(port)) - -def _run_program(filename): - """Runs the given program in a new process and new terminal.""" - if sys.platform[:3] == 'win': - os.startfile(filename) - global our_router - our_router = True - else: - # Linux possibilities: - # sh -c command - # xterm -e command - # bash -c command - # Try os.spawnl() with the above. - raise ValueError('unimplemented') - -def start(dir=None, hidden=False): - """Start a locally installed I2P router. Does nothing if - the router has already been started. - - An I2P installation is located by using find(dir). - - If hidden is True, do not show a terminal for the router. - """ - routerdir = find(dir) - router = os.path.join(routerdir, 'startRouter.bat') - try: - check(dir) - return # Already running - except: - pass # Not yet running - - olddir = os.getcwd() - - if hidden: - raise ValueError('unimplemented') - - our_router_lock.acquire() - try: - os.chdir(routerdir) - try: - _run_program(router) - finally: - os.chdir(olddir) - finally: - our_router_lock.release() - - # Ideas for hidden=True: - # Parse startRouter.bat, and run same command with javaw - # on Windows to hide command box. - # Perhaps use javaw (?) or javaws (j2sdk1.4.2/jre/javaws/javaws) - # Perhaps /path-to/program 2>/dev/null 1>/dev/null& - -def _parse_config(filename): - """Return a dict with (name, value) items for the given I2P configuration file.""" - f = open(filename, 'r') - s = f.read() - f.close() - ans = {} - for line in s.split('\n'): - line = line.strip() - if '#' in line: line = line[:line.find('#')] - pair = line.split('=') - if len(pair) == 2: - ans[pair[0].strip()] = pair[1].strip() - return ans - -def stop(dir=None, force=False): - """Stop a locally installed I2P router, if it was started by - the current Python program. If force is True, stop the - router even if it was started by another process. Do nothing - if force is False and the router was started by another program. - - The file 'router.config' is located using the same search - process used for find(dir). It is parsed for - 'router.shutdownPassword' and 'router.adminPort'. The - router is shut down through the admin port. - - Raises i2p.RouterError if the I2P router is running but cannot - be stopped. You must uncomment the - 'router.shutdownPassword' line for this command to work. - """ - if force == False and our_router == False: - return - - config = _parse_config(os.path.join(find(dir), router_config)) - - password = config.get('router.shutdownPassword', '') - if password == '': - raise ValueError('router.shutdownPassword not found in ' + - router_config) - admin_port = config.get('router.adminPort', '') - if admin_port == '': - raise ValueError('router.adminPort not found in ' + router_config) - - try: - admin_port = int(admin_port) - except: - raise ValueError('invalid router.adminPort in ' + router_config) - - try: - sock = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_STREAM) - sock.connect(('127.0.0.1', admin_port)) - sock.send('GET /shutdown?password=' + password + ' HTTP/1.0\r\n\r\n') - time.sleep(0.01) - sock.close() - except: - raise i2p.RouterError('router shutdown failed') - - # Assume shutdown succeeded (it will take 30 seconds). diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/samclasses.py i2p-0.9.50/apps/sam/python/src/i2p/samclasses.py --- i2p-0.9.49/apps/sam/python/src/i2p/samclasses.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/samclasses.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,773 +0,0 @@ - -# ------------------------------------------------------------- -# samclasses.py: Lower-level SAM classes, for internal use. -# ------------------------------------------------------------- - -""" -Lower-level SAM API, interfaces with SAM Bridge. - -For internal use only. - -Use the higher level i2p.socket module for your own programs. - -For details on SAM, see "Simple Anonymous Messaging (SAM) v1.0," -as published by jrandom. - -Class Overview: - - - SAMTerminal: Message sender/reader, talks to SAM Bridge. - - StringBuffer: Queue for character data. - - BaseSession: SAM session classes are derived from this. - - StreamSession: SAM stream session class, threadsafe, high level. - - DatagramSession: SAM datagram session, threadsafe, high level. - - RawSession: SAM raw session, threadsafe, high level. - -Note that a 'None' timeout is an infinite timeout: it -blocks forever if necessary. - -Todo: - - Error handling is a huge mess. Neaten it up. - Subclass a ErrorMixin class, then use set_error(e), - check_error(), get_error(). - - Streams are a huge mess. Neaten them up. - - This whole interface is a tad confusing. Neaten it up. -""" - -# --------------------------------------------------------- -# Imports -# --------------------------------------------------------- - -import Queue, traceback, random, sys, shlex -import thread, threading, time, string - -# --------------------------------------------------------- -# Import i2p and i2p.socket (for defaults and errors) -# --------------------------------------------------------- - -import i2p -import i2p.socket -from i2p.pylib import socket as pysocket # Import Python socket - -# --------------------------------------------------------- -# Functions -# --------------------------------------------------------- - -def sleep(): time.sleep(0.01) # Sleep between thread polls -def timer(): return time.time() # High resolution timer - # Do NOT use time.clock() as it - # drops sleep() time on Linux. - -log = False # Logging flag. Logs to ./log.txt. - -# ----------------------------------------------------- -# SAMTerminal -# ----------------------------------------------------- - -class SAMTerminal: - """Message-by-message communication with SAM through a single - pysocket. _on_* messages are dispatched to msgobj.""" - - def __init__(self, addr, msgobj): - try: self.host, self.port = addr.split(':') - except: raise ValueError('sam port required') - self.port = int(self.port) - self.sock=pysocket.socket(pysocket.AF_INET,pysocket.SOCK_STREAM) - self.msgobj = msgobj - try: - self.sock.connect((self.host, self.port)) - except: - raise i2p.RouterError('could not contact SAM bridge on ' + - self.host + ':' + str(self.port)) - thread.start_new_thread(self._poll_loop, ()) - self.error = None - self.lost_error = i2p.RouterError('SAM bridge connection lost') - - def _poll_loop(self): - """Polling loop for incoming messages.""" - try: - while True: - # Read until newline - line = [] - while True: - try: c = self.sock.recv(1) - except pysocket.error, ex: self.error = self.lost_error - if c == '': self.error = self.lost_error - if self.error != None: return - if c == '\n': break - if c != '': line += [c] - line = ''.join(line) - if log: - logf = open('log.txt', 'a') - logf.write('\n' + line + '\n') - logf.close() - (msg, kwargs) = self._samdecode(line) - # Read N bytes if SIZE=N is present. - if 'SIZE' in kwargs: - data = [] - remain = int(kwargs['SIZE']) - while True: - try: s = self.sock.recv(remain) - except pysocket.error, ex: self.error = self.lost_error - if s == '': self.error = self.lost_error - if self.error != None: return - if s != '': data += [s] - remain -= len(s) - if remain <= 0: break - data = ''.join(data) - # Store the read data in kwargs['DATA']. - kwargs['DATA'] = data - del kwargs['SIZE'] - # Dispatch the message - try: self.on_message(msg, kwargs) - except Exception, e: - # On exception in on_message, print a warning, keep going. - print 'Unhandled exception in polling thread.' - traceback.print_exc() - - # Don't need to sleep since recv() blocks. - # End of while loop - except Exception, e: - # For other exceptions, print a fatal error and stop polling. - print 'Fatal exception in polling thread' - traceback.print_exc(); sys.exit() - - def _samdecode(self, s): - """Given a SAM command, returns (a, b), where a is the string at - the beginning of the command, and b is a dictionary of name, - value pairs for the command.""" - (args, kwargs) = ([], {}) - for w in shlex.split(s): - if '=' in w: kwargs[w.split('=')[0]] = w.split('=')[1] - else: args += [w] - return (' '.join(args), kwargs) - - def check_message(self, kwargs): - """Raises an error if kwargs['RESULT'] != 'OK'.""" - if not kwargs.get('RESULT', '') in ['OK', '']: - raise i2p.socket.NetworkError((kwargs['RESULT'], - kwargs.get('MESSAGE', ''))) - - def on_message(self, msg, kwargs): - """Process a SAM message that was received. Dispatch to - self._on_MESSAGE_NAME(**kwargs).""" - name = '_on_' + msg.upper().replace(' ', '_') - getattr(self.msgobj, name)(**kwargs) - - def send_message(self, msg): - """Send a message to the SAM bridge. A newline will be - automatically added if none is present.""" - self.check() - if not '\n' in msg: msg = msg + '\n' - if log: - logf = open('log.txt', 'a') - logf.write('\n' + msg) - logf.close() - try: self.sock.sendall(msg) - except pysocket.error: self.error = self.lost_error - self.check() - - def check(self): - """Raise an error if terminal was closed, otherwise do - nothing.""" - if self.error != None: raise self.error - - def close(self): - """Close the SAM terminal.""" - # If data is sent via STREAM SEND, and the socket is closed - # immediately, the data will be lost. Delay 0.01 s to fix this - # bug (tested Windows, Linux). - time.sleep(0.01) - self.error = i2p.socket.ClosedError() - self.sock.close() - - def queue_get(self, q): - """Identical to q.get() unless a call to self.check() fails, - in which case the waiting is cut short with an error.""" - while True: - try: return q.get_nowait() - except Queue.Empty: pass - self.check() - sleep() - - -# ------------------------------------------------------- -# StringBuffer: A FIFO for string data. -# ------------------------------------------------------- - -class Deque: - """A double-ended queue.""" - def __init__(self): - self.a = [] - self.b = [] - def push_last(self, obj): - """Append obj to the end of the deque.""" - self.b.append(obj) - def push_first(self, obj): - """Prepend obj to the beginning of the deque.""" - self.a.append(obj) - def _partition(self): - if len(self) > 1: - self.a.reverse() - all = self.a + self.b - n = len(all) / 2 - self.a = all[:n] - self.b = all[n:] - self.a.reverse() - def pop_last(self): - """Pop an item off the end of the deque, and return it.""" - if not self.b: self._partition() - try: return self.b.pop() - except: return self.a.pop() - def pop_first(self): - """Pop an item off the beginning of the deque, and return it.""" - if not self.a: self._partition() - try: return self.a.pop() - except: return self.b.pop() - def __len__(self): - """Number of items in the deque.""" - return len(self.b) + len(self.a) - -class StringBuffer(Deque): - """A FIFO for characters. Strings can be efficiently - appended to the end, and read from the beginning. - - Example: - >>> B = StringBuffer('Hello W') - >>> B.append('orld!') - >>> B.read(5) - 'Hello' - >>> B.read() - 'World!' - """ - def __init__(self, s=''): - Deque.__init__(self) - self.length = 0 - self.append(s) - def append(self, s): - """Append string data to the end of the buffer.""" - n = 128 - for block in [s[i:i+n] for i in range(0,len(s),n)]: - self.push_last(block) - self.length += len(s) - def prepend(self, s): - """Prepend string data to the beginning of the buffer.""" - n = 128 - blocks = [s[i:i+n] for i in range(0,len(s),n)] - blocks.reverse() - for block in blocks: - self.push_first(block) - self.length += len(s) - def read(self, n=None): - """Read n bytes of data (or less if less data available) from the - beginning of the buffer. The data is removed. If n is - omitted, read the entire buffer.""" - if n == None or n > len(self): n = len(self) - destlen = len(self) - n - ans = [] - while len(self) > destlen: - ans += [self.pop_first()] - self.length -= len(ans[-1]) - ans = ''.join(ans) - self.prepend(ans[n:]) - ans = ans[:n] - return ans - def peek(self, n=None): - """Like read(), but do not remove the data that is returned.""" - ans = self.read(n) - self.prepend(ans) - return ans - def __len__(self): return self.length - def __str__(self): return self.peek() - def __repr__(self): return 'StringBuffer(' + str(self) + ')' - -# ----------------------------------------------------- -# BaseSession -# ----------------------------------------------------- - -class BaseSession: - """Base session, from which StreamSession, DatagramSession, - and RawSession are derived.""" - - def __init__(self, addr=''): - if addr == '': addr = i2p.socket.samaddr - self.term = SAMTerminal(addr=addr, msgobj=self) - self.lock = threading.Lock() # Data lock. - self.closed = False - self.qhello = Queue.Queue() # Thread messaging, HELLO REPLY. - self.qnaming = Queue.Queue() # Thread messaging, NAMING REPLY. - self.qsession = Queue.Queue() # Thread messaging, SESSION STATUS. - self._hello() # Do handshake with SAM bridge. - - def _hello(self): - """Internal command, handshake with SAM terminal.""" - self.term.send_message('HELLO VERSION MIN=' + - str(i2p.socket.samver) + ' MAX=' + str(i2p.socket.samver)) - self.term.check_message(self.term.queue_get(self.qhello)) - - def _on_HELLO_REPLY(self, **kwargs): - """Internal command, got HELLO REPLY.""" - self.qhello.put(kwargs) # Pass kwargs back to _hello. - - def _on_SESSION_STATUS(self, **kwargs): - """Internal command, got SESSION STATUS.""" - self.qsession.put(kwargs) # Pass kwargs back to main thread. - - def _namelookup(self, name): - """Internal command, does a NAMING LOOKUP query.""" - self.term.send_message('NAMING LOOKUP NAME=' + name) - # Read back response, check it, and return X in VALUE=X. - kwargs = self.term.queue_get(self.qnaming) - self.term.check_message(kwargs) - return kwargs['VALUE'] - - def _on_NAMING_REPLY(self, **kwargs): - """Internal command, got NAMING REPLY.""" - self.qnaming.put(kwargs) # Pass kwargs back to _namelookup. - - def _set_properties(self): - """Internal command, call at end of __init__ to set up - properties.""" - self.dest = self._namelookup('ME') - - def close(self): - """Close the session.""" - # Synchronize - self.lock.acquire() - try: - # Close the terminal if we're not already closed. - if not self.closed: self.term.close() - self.closed = True - finally: self.lock.release() - - def _encode_kwargs(self, **kwargs): - """Internal command, encode extra kwargs for passing to - SESSION CREATE.""" - ans = '' - for k in kwargs: - if k == 'in_depth': - ans += ' tunnels.depthInbound=' + \ - str(int(kwargs['in_depth'])) - elif k == 'out_depth': - ans += ' tunnels.depthOutbound=' + \ - str(int(kwargs['out_depth'])) - else: - raise ValueError('unexpected keyword argument ' + repr(k)) - return ans - -# ----------------------------------------------------- -# StreamSession -# ----------------------------------------------------- - -class StreamSession(BaseSession): - """Stream session. All methods are blocking and threadsafe.""" - - def __init__(self, name, addr='', **kwargs): - if addr == '': addr = i2p.socket.samaddr - BaseSession.__init__(self, addr) - self.idmap = {} # Maps id to Stream object. - self.qaccept = Queue.Queue() # Thread messaging, accept. - self.name = name - self.max_accept = 0 # Max queued incoming connections. - - # Create stream session. - if name == '': - name = 'TRANSIENT' - - # DIRECTION=BOTH (the default) is used because we can't know in - # advance whether a session will call listen(). - - self.term.send_message('SESSION CREATE STYLE=STREAM' + - ' DESTINATION=' + name + self._encode_kwargs(**kwargs)) - self.term.check_message(self.term.queue_get(self.qsession)) - - self._set_properties() - - def connect(self, dest, timeout=None): - """Create a stream connected to remote destination 'dest'. The - id is random. If the timeout is exceeded, do NOT raise an - error; rather, return a Stream object with .didconnect set - to False.""" - if not isinstance(dest, type('')): raise TypeError - # Synchronize - self.lock.acquire() - try: - # Pick a positive stream id at random. - while True: - # 9/10 probability of success per iteration - id = random.randrange(1, len(self.idmap) * 10 + 2) - if not id in self.idmap: - ans = Stream(self, dest, id, didconnect=False) - self.idmap[id] = ans - break - finally: self.lock.release() - # Send STREAM CONNECT and wait for reply. - self.term.send_message('STREAM CONNECT ID=' + str(id) + - ' DESTINATION=' + str(dest)) - - # Now wait until the stream's .didconnect flag is set to True. - if timeout != None: end = timer() + timeout - while True: - self.term.check() - if ans.didconnect: break - if timeout != None and timer() >= end: break - sleep() - - return ans - - def _on_STREAM_STATUS(self, **kwargs): - """Internal command, got STREAM STATUS. Unblocks connect.""" - # Store error is needed - try: self.term.check_message(kwargs) - except Exception, e: - try: self.idmap[int(kwargs['ID'])].err = e - except: pass # Closed too quickly - - # Now set .didconnect flag to True. - try: self.idmap[int(kwargs['ID'])].didconnect = True - except: pass # Closed too quickly - - def accept(self, timeout=None): - """Wait for incoming connection, and return a Stream object - for it.""" - if self.max_accept <= 0: - raise i2p.Error('listen(n) must be called before accept ' + - '(n>=1)') - if timeout != None: end = timer() + timeout - while True: - self.term.check() - # Synchronized - self.lock.acquire() - try: - # Get Stream object if available. - if self.qaccept.qsize() > 0: - return self.term.queue_get(self.qaccept) - finally: self.lock.release() - if timeout != None and timer() >= end: break - sleep() - - # Handle timeout and blocking errors - if timeout == 0.0: - raise i2p.socket.BlockError('command would have blocked') - else: - raise i2p.socket.Timeout('timed out') - - def listen(self, backlog): - """Set maximum number of queued connections.""" - if self.closed: raise sam.ClosedError() - self.max_accept = backlog - - def _on_STREAM_CONNECTED(self, **kwargs): - """Got STREAM CONNECTED command. This is what accept() commands - wait for.""" - # Synchronize - self.lock.acquire() - try: - # Drop connection if over maximum size. - if self.qaccept.qsize() >= self.max_accept: - self.term.send_message('STREAM CLOSE ID=' + - str(int(kwargs['ID']))) - return - - # Parse, create Stream, and place on self.qaccept. - self.term.check_message(kwargs) - # A negative id is chosen for us - id = int(kwargs['ID']) - self.idmap[id] = Stream(self, kwargs['DESTINATION'], id) - # Pass Stream object back to accept. - self.qaccept.put(self.idmap[id]) - finally: self.lock.release() - - def _send_stream(self, id, data): - """Internal command, send data to stream id. Use Stream.send - in your code.""" - self.term.send_message('STREAM SEND ID=' + str(id) + ' SIZE=' + - str(len(data)) + '\n' + data) - - def _on_STREAM_CLOSED(self, **kwargs): - """Got STREAM CLOSED command. Call idmap[id].on_close(e) and - delete idmap[id].""" - id = int(kwargs['ID']) - - # No error is produced for a graceful remote close. - e = None - try: self.term.check_message(kwargs) - except i2p.Error, err: e = err - - # Synchronize - self.lock.acquire() - try: - # Sent STREAM CLOSE, SAM didn't hear us in time. - if not id in self.idmap: return - # Pop id from self.idmap, if available. - obj = self.idmap[id] - del self.idmap[id] - finally: self.lock.release() - - # Process on_close message. - obj.on_close(None) - - def _on_STREAM_RECEIVED(self, **kwargs): - """Got STREAM RECEIVED command. Dispatch to - idmap[id].on_receive(s).""" - id = int(kwargs['ID']) - if not id in self.idmap: - # _on_STREAM_CONNECTED blocks until self.idmap[id] is properly - # set up. Therefore, we have received a stream packet despite - # closing the stream immediately after _on_STREAM_CONNECTED - # (SAM ignored us). So ignore it. - return - self.idmap[id].on_receive(kwargs['DATA']) - - def __len__(self): - """Unconnected session; has no read data available.""" - return 0 - - -class Stream: - """Receives and sends data for an individual stream.""" - - def __init__(self, parent, remotedest, id, didconnect=True): - self.parent = parent - self.buf = StringBuffer() - self.localdest = parent.dest - self.remotedest = remotedest - self.id = id - # Data lock. Allow multiple acquire()s by same thread - self.lock = threading.RLock() - self.closed = False - # Error message, on STREAM STATUS, or on STREAM CLOSED. - self.err = None - # Whether stream got a STREAM CONNECTED message - self.didconnect = didconnect - - def send(self, s): - """Sends the string s, blocking if necessary.""" - id = self.id - if self.closed or id == None: - if self.err != None: raise self.err - raise i2p.socket.ClosedError('stream closed') - if len(s) == 0: return - nmax = 32768 - for block in [s[i:i+nmax] for i in range(0,len(s),nmax)]: - self.parent._send_stream(id, block) - - def recv(self, n, timeout=None, peek=False, waitall=False): - """Reads up to n bytes in a manner identical to socket.recv. - Blocks for up to timeout seconds if n > 0 and no data is - available (timeout=None means wait forever). If still no data - is available, raises BlockError or Timeout. For a closed - stream, recv will read the data stored in the buffer until - EOF, at which point the read data will be truncated. If peek - is True, the data is not removed. If waitall is True, reads - exactly n bytes, or raises BlockError or Timeout as - appropriate. Returns data.""" - - if n < 0: raise ValueError - if n == 0: return '' - - minlen = 1 - if waitall: minlen = n - - if timeout != None: end = timer() + timeout - while True: - # Synchronized check and read until data available. - self.parent.term.check() - self.lock.acquire() - try: - if len(self.buf) >= minlen: - if peek: return self.buf.peek(n) - else: return self.buf.read(n) - # Graceful close: return as much data as possible - # (up to n bytes). - if self.closed and self.err == None: return self.buf.read(n) - # Ungraceful close: raise an error. - if self.err != None: raise self.err - finally: self.lock.release() - if timeout != None and timer() >= end: break - sleep() - - # Handle timeout and blocking error - if timeout == 0.0: - raise i2p.socket.BlockError('command would have blocked') - else: - raise i2p.socket.Timeout('timed out') - - def __len__(self): - """Current length of read buffer.""" - return len(self.buf) - - def close(self): - """Close the stream. Threadsafe.""" - # Synchronize self.parent. - self.parent.lock.acquire() - try: - if not self.closed: - self.closed = True - id = self.id - # Set self.id to None, so we don't close a new stream by - # accident. - self.id = None - if not id in self.parent.idmap: return - self.parent.term.send_message('STREAM CLOSE ID=' + str(id)) - # No error is produced for a locally closed stream - self.on_close(None) - del self.parent.idmap[id] - finally: self.parent.lock.release() - - def on_receive(self, s): - # Synchronize - self.lock.acquire() - try: - self.buf.append(s) - finally: self.lock.release() - - def on_close(self, e): - self.closed = True - self.err = e - - def __del__(self): - self.close() - -# ----------------------------------------------------- -# DatagramSession -# ----------------------------------------------------- - -class DatagramSession(BaseSession): - """Datagram session. All methods are blocking and threadsafe.""" - - def __init__(self, name, addr='', **kwargs): - if addr == '': addr = i2p.socket.samaddr - BaseSession.__init__(self, addr) - self.buf = Deque() # FIFO of incoming packets. - self.name = name - - # Create datagram session - if name == '': name = 'TRANSIENT' - self.term.send_message('SESSION CREATE STYLE=DATAGRAM ' + - 'DESTINATION=' + name + self._encode_kwargs(**kwargs)) - self.term.check_message(self.term.queue_get(self.qsession)) - - self._set_properties() - - def _on_DATAGRAM_RECEIVED(self, **kwargs): - """Internal method, got DATAGRAM RECEIVED.""" - # Synchronized - self.lock.acquire() - try: - self.buf.push_last((kwargs['DATA'], kwargs['DESTINATION'])) - finally: self.lock.release() - - def send(self, s, dest): - """Send packet with contents s to given destination.""" - # Raise error if packet is too large. - if len(s) > i2p.socket.MAX_DGRAM: - raise ValueError('packets must have length <= ' + - str(i2p.socket.MAX_DGRAM) + ' bytes') - self.term.send_message('DATAGRAM SEND DESTINATION=' + dest + - ' SIZE=' + str(len(s)) + '\n' + s) - - def recv(self, timeout=None, peek=False): - """Get a single packet. Blocks for up to timeout seconds if - n > 0 and no packet is available (timeout=None means wait - forever). If still no packet is available, raises BlockError - or Timeout. Returns the pair (data, address). If peek is - True, the data is not removed.""" - if timeout != None: end = timer() + timeout - while True: - self.term.check() - # Synchronized check and read until data available. - self.lock.acquire() - try: - if len(self.buf) > 0: - if peek: - ans = self.buf.pop_first() - self.buf.push_first(ans) - return ans - else: - return self.buf.pop_first() - finally: self.lock.release() - if timeout != None and timer() >= end: break - sleep() - - # Handle timeout and blocking error - if timeout == 0.0: - raise i2p.socket.BlockError('command would have blocked') - else: - raise i2p.socket.Timeout('timed out') - - def __len__(self): - """Number of packets in read buffer.""" - return len(self.buf) - -# ----------------------------------------------------- -# RawSession -# ----------------------------------------------------- - -class RawSession(BaseSession): - """Raw session. All methods are blocking and threadsafe.""" - - def __init__(self, name, addr='', **kwargs): - if addr == '': addr = i2p.socket.samaddr - BaseSession.__init__(self, addr) - self.buf = Deque() # FIFO of incoming packets. - self.name = name - - # Create raw session - if name == '': name = 'TRANSIENT' - self.term.send_message('SESSION CREATE STYLE=RAW DESTINATION=' + - name + self._encode_kwargs(**kwargs)) - self.term.check_message(self.term.queue_get(self.qsession)) - - self._set_properties() - - def _on_RAW_RECEIVED(self, **kwargs): - """Internal method, got RAW RECEIVED.""" - # Synchronized - self.lock.acquire() - try: - self.buf.push_last((kwargs['DATA'], '')) - finally: self.lock.release() - - def send(self, s, dest): - """Send packet with contents s to given destination.""" - # Raise error if packet is too big - if len(s) > i2p.socket.MAX_RAW: - raise ValueError('packets must have length <= ' + - str(i2p.socket.MAX_RAW) + ' bytes') - self.term.send_message('RAW SEND DESTINATION=' + dest + - ' SIZE=' + str(len(s)) + '\n' + s) - - def recv(self, timeout=None, peek=False): - """Identical to DatagramSocket.recv. The from address is an - empty string.""" - if timeout != None: end = timer() + timeout - while True: - self.term.check() - # Synchronized check and read until data available. - self.lock.acquire() - try: - if len(self.buf) > 0: - if peek: - ans = self.buf.pop_first() - self.buf.push_first(ans) - return ans - else: - return self.buf.pop_first() - finally: self.lock.release() - if timeout != None and timer() >= end: break - sleep() - - # Handle timeout and blocking error - if timeout == 0.0: - raise i2p.socket.BlockError('command would have blocked') - else: - raise i2p.socket.Timeout('timed out') - - def __len__(self): - """Number of packets in read buffer.""" - return len(self.buf) - - -# ----------------------------------------------------- -# End of file -# ----------------------------------------------------- diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/select.py i2p-0.9.50/apps/sam/python/src/i2p/select.py --- i2p-0.9.49/apps/sam/python/src/i2p/select.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/select.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,166 +0,0 @@ - -# ------------------------------------------------------------- -# select.py: Emulation of Python select module. -# ------------------------------------------------------------- - -""" -I2P Python API - Emulation of Python select module. -""" - -import time - -import i2p.socket -from i2p.pylib import select as pyselect # Import Python select - -# -------------------------------------------------- -# Poll and select -# -------------------------------------------------- - -POLLIN = 1 # There is data to read -POLLPRI = 1 # Same as POLLIN -POLLOUT = 4 # Ready for output -POLLERR = 8 # Wait for error condition -POLLHUP = 16 # Not implemented -POLLNVAL = 32 # Not implemented - -class Poll: - """Class implementing poll interface. Works for Python sockets - and SAM sockets.""" - def __init__(self): - self.fds = {} # Maps _hash() -> (socket, mask) - def _hash(self, fd): - """Get a unique number for each object.""" - if isinstance(fd, int): - return fd # Use the fd itself if integer. - else: - return id(fd) # Use object address (no copies!) - def register(self, fd, eventmask=POLLIN|POLLOUT|POLLERR): - self.fds[self._hash(fd)] = (fd, eventmask) - def unregister(self, fd): - del self.fds[self._hash(fd)] - def poll(self, timeout=None): - readlist, writelist, errlist = [], [], [] - for F, mask in self.fds.values(): - if mask & POLLIN: readlist += [F] - if mask & POLLOUT: writelist += [F] - if mask & POLLERR: errlist += [F] - (Rs, Ws, Es) = select(readlist, writelist, errlist, - timeout=timeout) - ans = [] - for R in Rs: ans.append((R, POLLIN)) - for W in Ws: ans.append((W, POLLOUT)) - for E in Es: ans.append((E, POLLERR)) - return ans - -def poll(): - """Returns a polling object. Works on SAM sockets and Python - sockets. See select.poll() in the Python library for more - information. - - Polling flags specified in this module: - - POLLIN - - POLLOUT - - POLLERR - - POLLHUP - - POLLNVAL - - POLLPRI -""" - return Poll() - -def _has_data(S): - """True if the given I2P socket has data waiting.""" - try: - S.recv(1, i2p.socket.MSG_PEEK | i2p.socket.MSG_DONTWAIT) - return True - except: - return False - -def _noblock_select(readlist, writelist, errlist): - """Makes a single query of the given sockets, like - select() with timeout 0.0.""" - Rans = [] - Wans = [] - Eans = [] - - # Check for read availability. - for R in readlist: - if isinstance(R, int) or hasattr(R, 'fileno'): - # Python socket - if len(pyselect.select([R], [], [], 0.0)[0]) > 0: - Rans.append(R) - else: - # SAM Socket - if _has_data(R): - Rans.append(R) -# if R.type == i2p.socket.SOCK_STREAM: -# try: -# R._verify_connected() -# Rans.append(R) -# except: -# pass -# else: -# if len(R.sessobj) > 0: Rans.append(R) - - # Check for write availability. - for W in writelist: - if isinstance(W, int) or hasattr(W, 'fileno'): - # Python socket - if len(pyselect.select([], [W], [], 0.0)[1]) > 0: - Wans.append(W) - else: - # SAM Socket - if W.type == i2p.socket.SOCK_STREAM: - try: - W._verify_connected() - Wans.append(W) - except: - pass - else: - Wans.append(W) - - # Check for error conditions. - # These can only be stream errors. - for E in errlist: - if isinstance(E, int) or hasattr(E, 'fileno'): - # Python socket - if len(pyselect.select([], [], [E], 0.0)[2]) > 0: - Eans.append(E) - else: - if E.type == i2p.socket.SOCK_STREAM: - try: - # FIXME: Use a ._get_error() function for errors. - # Socket can only have an error if it connected. - E._verify_connected() - if E.sessobj.err != None: - Eans.append(E) - except: - pass - - return (Rans, Wans, Eans) - - -def select(readlist, writelist, errlist, timeout=None): - """Performs a select call. Works on SAM sockets and Python - sockets. See select.select() in the Python library for more - information.""" - - if timeout != None: end = time.time() + timeout - while True: - # FIXME: Check performance. - # Use pyselect.poll for Python sockets, if needed for speed. - (Rans, Wans, Eans) = _noblock_select(readlist,writelist,errlist) - - if timeout != None and time.time() >= end: break - if len(Rans) != 0 or len(Wans) != 0 or len(Eans) != 0: - # One or more sockets are ready. - if timeout != 0.0: - # Check again, because sockets may have changed state while - # we did _noblock_select (it's safer to check twice, since - # they usually go from no data => data ready, and so forth). - (Rans, Wans, Eans) = _noblock_select(readlist, writelist, - errlist) - return (Rans, Wans, Eans) - - time.sleep(0.01) - - return (Rans, Wans, Eans) diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/SimpleHTTPServer.py i2p-0.9.50/apps/sam/python/src/i2p/SimpleHTTPServer.py --- i2p-0.9.49/apps/sam/python/src/i2p/SimpleHTTPServer.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/SimpleHTTPServer.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,68 +0,0 @@ -#! /usr/bin/env python - -""" -Emulation of Python SimpleHTTPServer module using I2P sockets. - -The Python module is described at -http://www.python.org/doc/current/lib/module-SimpleHTTPServer.html - -To get a server going, use: - - >>> from i2p import SimpleHTTPServer - >>> SimpleHTTPServer.test(). - -Consult the documentation for function test() to change basic -server settings, such as the session name. - -A fully customizable example: - - >>> from i2p import BaseHTTPServer, SimpleHTTPServer - >>> session = "mytestxxx.i2p" # SAM session name - >>> class MyServer(BaseHTTPServer.HTTPServer): pass - >>> class MyRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): pass - >>> httpd = MyServer(session, MyRequestHandler) - >>> httpd.socket.dest - (Base64 Destination of server) - >>> httpd.serve_forever() - -""" - -# By aum. - -# Hack to keep Python from importing from current directory: -# Use pylib package, then use = signs instead of from x import y. -import pylib -SimpleHTTPServer = pylib.SimpleHTTPServer - -import sys -import i2p.BaseHTTPServer - -__version__ = "0.1.0" - -__all__ = ["SimpleHTTPRequestHandler", "test"] - -HTTPServer = i2p.BaseHTTPServer.HTTPServer -class SimpleHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): - """ - Same interface as Python class - SimpleHTTPServer.SimpleHTTPRequestHandler. - """ - -def test(HandlerClass = SimpleHTTPRequestHandler, - ServerClass = i2p.BaseHTTPServer.HTTPServer, - session = "mytestxxx.i2p"): - """ - Test the HTTP simple request handler class. - - This runs an I2P TCP server under SAM session 'session'. - If a single command line argument is given, the argument is used - instead as the SAM session name. - """ - if sys.argv[1:] and __name__ == '__main__': - session = sys.argv[1] - - i2p.BaseHTTPServer.test(HandlerClass, ServerClass, - session=session) - -if __name__ == '__main__': - test() diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/socket.py i2p-0.9.50/apps/sam/python/src/i2p/socket.py --- i2p-0.9.49/apps/sam/python/src/i2p/socket.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/socket.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,535 +0,0 @@ - -# ------------------------------------------------------------- -# socket.py: Emulation of Python socket module. -# ------------------------------------------------------------- - -""" -Emulation of Python socket module using SAM. -""" - -import i2p - -import samclasses, threading, time, copy, Queue, thread -from i2p.pylib import socket as pysocket # Import Python socket -from i2p.pylib import select as pyselect # Import Python select - -# -------------------------------------------------- -# Global variables -# -------------------------------------------------- - -# Ports -samaddr = '127.0.0.1:7656' # Default port for SAM Bridge - -# Flags for recv, recvfrom. -MSG_PEEK = 2 # Peek at incoming message -MSG_WAITALL = 64 # Wait for data or error -MSG_DONTWAIT = 128 # Nonblocking - -# Packet sizes -MAX_DGRAM = 31744 # Max size of datagram packet -MAX_RAW = 32768 # Max size of raw packet - -# Socket types -SOCK_STREAM = 1 # Stream socket -SOCK_DGRAM = 2 # Datagram socket -SOCK_RAW = 3 # Raw socket - -# Miscellaneous -samver = 1.0 # SAM version implemented - -# -------------------------------------------------- -# Errors -# -------------------------------------------------- - -class Error(i2p.Error): - """Base class for all SAM errors.""" - -class NetworkError(Error): - """Network error occurred within I2P. - The error object is a 2-tuple: (errtag, errdesc). - errtag is a SAM error string, - errdesc is a human readable error description. - """ - -class ClosedError(Error): - """A command was used on a socket that closed gracefully.""" - -class BlockError(Error): - """Socket call would have blocked.""" - -class Timeout(Error): - """Time out occurred for a socket which had timeouts enabled - via a prior call to settimeout().""" - -# -------------------------------------------------- -# Sockets -# -------------------------------------------------- - -# Note: socket(), __make_session() and Socket() should have same args -def socket(session, type, samaddr=samaddr, **kwargs): - r"""Create a new socket. Argument session should be a session - name -- if the name has not yet been used, an I2P - Destination will be created for it, otherwise, the - existing Destination will be re-used. An empty session - string causes a transient session to be created. Argument - type is one of SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - I2P configuration keyword arguments: - - - in_depth - depth of incoming tunnel (default 2) - - out_depth - depth of outgoing tunnel (default 2) - - A single session may be shared by more than one socket, if - the sockets are the same type, and if the sockets are - created within the same Python process. The socket - objects are multithread-safe. - - Examples: - >>> a = i2p.socket('Alice', i2p.SOCK_STREAM) - >>> b = i2p.socket('Bob', i2p.SOCK_DGRAM, - in_depth=2, out_depth=5) - - The created object behaves identically to a socket from - module socket, with the following exceptions: - - - I2P Destinations are used as address arguments [1]. - - bind is a no-op: sockets are always bound. - - send* methods send all data and are non-blocking. - - A given session name can only be open in a single Python - program at a time. If you need to overcome this - limitation, consider patching I2P. - - [1]. - Alternatively, a host name can be used as an address. - It will be resolved using hosts.txt. - - For details on how to use socket objects, see - http://www.python.org/doc/current/lib/socket-objects.html - - See the examples directory for code examples. - """ - - return Socket(session, type, samaddr, **kwargs) - - -# -------------------------------------------------- -# Socket session objects -# -------------------------------------------------- - -# Global list of session objects. -_sessions = {} -_session_lock = threading.Lock() - -def _make_session(session, type, samaddr, **kwargs): - """Make a session object (eg samclasses.StreamSession). Same - arguments as socket(). Return an existing session object - if one has been previously created under the given name. - """ - # Synchronize - _session_lock.acquire() - try: - if type == SOCK_STREAM: C = samclasses.StreamSession - elif type == SOCK_DGRAM: C = samclasses.DatagramSession - elif type == SOCK_RAW: C = samclasses.RawSession - else: raise ValueError('bad socket type') - # Get existing session, if available - if session != '' and _sessions.has_key(session): - if _sessions[session].__class__ != C: - raise ValueError('session ' + repr(session) + ' was ' + - 'created with a different session type.') - return _sessions[session] - # Create new session - if type == SOCK_STREAM: ans = C(session, samaddr, **kwargs) - elif type == SOCK_DGRAM: ans = C(session, samaddr, **kwargs) - elif type == SOCK_RAW: ans = C(session, samaddr, **kwargs) - if session != '': _sessions[session] = ans - return ans - finally: _session_lock.release() - -def _wrap_stream(stream, parent_socket): - """Wraps a Socket object around a samclasses.Stream object.""" - s = Socket('', 0, dummy_socket=True) - s.sessobj = stream - s.remotedest = stream.remotedest - s.dest = parent_socket.dest - s.session = parent_socket.session - s.type = parent_socket.type - s.timeout = None - s.samaddr = parent_socket.samaddr - s.closed = False - return s - -# -------------------------------------------------- -# Socket class -# -------------------------------------------------- - -class Socket: - """A socket object.""" - - # Docstrings for pydoc. These variables will be overwritten. - dest = property(doc='Local I2P Destination of socket') - session = property(doc='Session name') - type = property(doc='Socket type: SOCK_STREAM, SOCK_DGRAM,' + - ' or SOCK_RAW.') - # FIXME: Use getsockopt to detect errors. - - def __init__(self, session, type, samaddr=samaddr, **kwargs): - """Equivalent to socket().""" - if kwargs.has_key('dummy_socket'): return - self.sessobj = _make_session(session, type, samaddr, **kwargs) - self.dest = self.sessobj.dest - self.session = session - self.type = type - self.timeout = None # None indicates blocking mode - self.samaddr = samaddr - self.closed = False # Was current object closed? - self.lock = threading.Lock() - - def _verify_open(self): - """Verify that the socket has not been closed.""" - if self.closed == True: - raise ClosedError('socket closed') - - def _verify_stream(self): - """Raise an error if socket is not a SOCK_STREAM.""" - if self.type != SOCK_STREAM: - raise i2p.Error('operation not supported') - # FIXME: Check for errors also. - - def _verify_connected(self, needs_to_be_connected=True): - """Raise an error if socket is not a connected stream socket.""" - self._verify_stream() - if not hasattr(self.sessobj, 'remotedest'): - raise i2p.Error('socket is not connected') - if needs_to_be_connected and not self.sessobj.didconnect: - raise i2p.Error('socket is in the process of connecting') - # FIXME: Check for errors also. - - def _verify_not_connected(self): - """Verify that the socket is not currently connected, and is not - in the process of connecting.""" - self._verify_stream() - if hasattr(self.sessobj, 'remotedest'): - raise i2p.Error('socket is already connected') - # FIXME: Check for errors also. - - def accept(self): - """Accept an incoming connection. The socket must be type - SOCK_STREAM, and listen() must be called prior to this - command. The return value is (conn, remotedest), where - conn is a new socket object made for the connection, and - remotedest is the remote Destination from which the - connection was made. - - Example: - - >>> from i2p import socket - >>> s = socket.socket('Alice', socket.SOCK_STREAM) - >>> s.listen(10) - - This prepares the server. Now accept an incoming connection: - - >>> c, remotedest = s.accept() - >>> c.send('hello world!') - - If accept() is called on a socket that is in non-blocking - mode or has a timeout, i2p.socket.BlockError or - i2p.socket.Timeout may be raised. This indicates that no - incoming connection is currently available.""" - - self._verify_open() - self._verify_not_connected() - # Raises BlockError or Timeout if not ready. - C = _wrap_stream(self.sessobj.accept(self.timeout), self) - return (C, C.remotedest) - - def bind(self, address): - """Does nothing. Provided for compatibility with the Python - socket command bind(), which binds a server to a port.""" - self._verify_open() - self._verify_not_connected() - - def close(self): - """Closes the socket. It is an error to call any method - other than recv() or recvfrom() on a closed socket. - For streams, the receive methods return data that was - received prior to the closing of the socket. For - datagram and raw sockets, the receive methods cannot - be used on a closed socket.""" - try: - self._verify_connected() - connected = True - except i2p.Error: - connected = False - if connected: - # Close the Stream object. - self.sessobj.close() - else: - # Never close a session object. - pass - self.closed = True - - def connect(self, address): - """ - Connect to a remote dest, identified in local SAM bridge's hosts - file as host 'address'. - - For example: - >>> s.connect('duck.i2p') - - Alternatively, you can use a full base64 Destination: - - Example: - >>> s.connect('238797sdfh2k34kjh....AAAA') - - If connect() is called on a socket that is in non-blocking - mode or has a timeout, i2p.socket.BlockError or - i2p.socket.Timeout may be raised. This indicates that the - connection is still being initiated. Use i2p.select.select() - to determine when the connection is ready. - """ - # Synchronized. Lock prevents two connects from occurring at the - # same time in different threads. - self.lock.acquire() - try: - self._verify_open() - if self.type == SOCK_DGRAM or self.type == SOCK_RAW: - self.packet_dest = address - return - - self._verify_not_connected() - - address = resolve(address, self.samaddr) - - timeout = self.timeout - unwrap = self.sessobj.connect(address, timeout=timeout) - w = _wrap_stream(unwrap, self) - self.sessobj = w.sessobj - self.remotedest = w.remotedest - - if self.sessobj.err != None: - raise self.sessobj.err - - # Raise error if not yet connected - if not self.sessobj.didconnect: - if timeout == 0.0: - raise BlockError('command would have blocked. use ' + - 'i2p.select.select() to find when socket is connected') - else: raise Timeout('timed out. use i2p.select.select()' + - ' to find when socket is connected') - - finally: self.lock.release() - - def connect_ex(self, address): - """Like connect(), but return any error that is raised. - Returns None if no error is raised.""" - try: self.connect(address) - except i2p.Error, e: return e - - # Don't implement fileno(), as we don't have a real file handle. - - def getpeername(self): - """Get the remote Destination associated with the socket. - This is equivalent to s.remotedest, and is provided for - compatibility with the Python socket module.""" - self._verify_connected() - return self.remotedest - - def getsockname(self): - """Get the local Destination associated with the socket. - This is equivalent to s.dest, and is provided for - compatibility with the Python socket module.""" - return self.dest - - def listen(self, backlog): - """Listen for connections made to the socket. - This method must be called before accept(). - The backlog argument specifies the maximum number of - queued incoming connections.""" - self._verify_open() - self._verify_not_connected() - self.sessobj.listen(backlog) - - def makefile(self, mode='r', bufsize=-1): - """Return a file object for the socket. - See socket.makefile() in the Python documentation for - more information.""" - self._verify_open() - self._verify_connected() - return pysocket._fileobject(self, mode, bufsize) - - def recv(self, bufsize, flags=0): - """Receive string data from the socket. - - The maximum amount of data to be received is given by - bufsize. If bufsize is zero, this function returns - an empty string immediately. If bufsize is nonzero, - this function blocks until at least one character is - available for reading. If the socket has been closed, - an empty string is returned as an end of file indicator. - - If recv() is called on a socket that is in non-blocking - mode or has a timeout, i2p.socket.BlockError or - i2p.socket.Timeout will be raised if data is not available - within the given timeframe. - - For a datagram or raw socket, the first bufsize characters - of the packet are read, and the remainder of the packet is - discarded. To read the entire packet, use bufsize = -1. - - For datagram and raw sockets, the packet may originate from - any Destination. Use recvfrom() with datagrams to determine - the Destination from which the packet was received. - - The flags argument can be a bitwise OR of MSG_PEEK, - MSG_WAITALL, and/or MSG_DONTWAIT. MSG_PEEK indicates that - any data read should not be removed from the socket's - incoming buffer. MSG_WAITALL indicates to wait for exactly - bufsize characters or an error. MSG_DONTWAIT indicates - that the recv() command should not block execution. - """ - - # FIXME: What about recv'ing if connected in asynchronous mode? - # It is acceptable to call recv() after a stream has closed - # gracefully. It is an error to call recv() after a stream has - # closed due to an I2P network error. - timeout = self.timeout - (peek, waitall, dontwait) = \ - (flags & MSG_PEEK, flags & MSG_WAITALL, flags & MSG_DONTWAIT) - if dontwait: timeout = 0.0 - - if self.type == SOCK_STREAM: - self._verify_connected() - return self.sessobj.recv(bufsize, timeout, peek, waitall) - else: - return self.recvfrom(bufsize, flags)[0] - - def recvfrom(self, bufsize, flags=0): - """Like recv(), but returns a tuple (data, remoteaddr), where - data is the string data received, and remoteaddr is the - remote Destination.""" - timeout = self.timeout - (peek, waitall, dontwait) = \ - (flags & MSG_PEEK, flags & MSG_WAITALL, flags & MSG_DONTWAIT) - if dontwait: timeout = 0.0 - - if self.type == SOCK_STREAM: - self._verify_connected() - if bufsize < 0: raise ValueError('bufsize must be >= 0 for streams') - return (self.sessobj.recv(bufsize, timeout, peek, waitall), \ - self.remotedest) - else: - if bufsize < -1: - raise ValueError('bufsize must be >= -1 for packets') - (data, addr) = self.sessobj.recv(timeout, peek) - if bufsize == -1: - return (data, addr) - else: - return (data[:bufsize], addr) - - def send(self, string, flags=0): - """Sends string data to a remote Destination. - - For a stream, connect() must be called prior to send(). - Once close() is called, no further data can be sent, and - the stream cannot be re-opened. - - For datagram and raw sockets, connect() only specifies - a Destination to which packets are sent to. send() will - then send a packet to the given Destination. connect() - can be used multiple times. - - The send() command never blocks execution. The flags - argument is ignored. - """ - - self._verify_open() - if self.type == SOCK_DGRAM or self.type == SOCK_RAW: - if not hasattr(self, 'packet_dest'): - raise i2p.Error('use connect or sendto to specify a ' + - 'Destination') - self.sendto(string, flags, self.packet_dest) - return - - self._verify_connected() - if self.closed: - raise i2p.Error('send operation on closed socket') - # FIXME: What about send'ing if connected in asynchronous mode? - self.sessobj.send(string) - - def sendall(self, string, flags=0): - """Identical to send().""" - self.send(string) - - def sendto(self, string, flags, address): - """Send a packet to the given Destination. - - Only valid for datagram and raw sockets. The address - argument should be either a name from the hosts file, - or a base64 Destination. - - The sendto() command never blocks execution. The flags - argument is ignored. - """ - - self._verify_open() - if not self.type in [SOCK_DGRAM, SOCK_RAW]: - raise i2p.Error('operation not supported') - if self.closed: - raise i2p.Error('sendto operation on closed socket') - address = resolve(address, self.samaddr) - self.sessobj.send(string, address) - - def setblocking(self, flag): - """Set blocking or non-blocking mode for the socket. - - If flag is True, any method called on the socket will - hang until the method has completed. If flag is False, - all methods will raise i2p.socket.BlockError() if they - cannot complete instantly. - - s.setblocking(False) is equivalent to s.settimeout(0); - s.setblocking(True) is equivalent to s.settimeout(None). - """ - if flag: self.timeout = None - else: self.timeout = 0.0 - - def settimeout(self, value): - """Set a timeout for the socket. - - The value argument should be a timeout value in seconds, - or None. None is equivalent to an infinite timeout. - - A socket operation will raise a i2p.socket.Timeout if - the operation cannot complete within in the specified - time limit. - """ - self.timeout = value - - def gettimeout(self): - """Get the timeout value.""" - return self.timeout - - def __copy__(self): - """Returns the original object.""" - return self - - def __deepcopy__(self, memo): - """Returns the original object.""" - return self - -def resolve(host, samaddr=samaddr): - """Resolve I2P host name --> I2P Destination. - Returns the same string if host is already a Destination.""" - if host.find('http://') == 0: host = host[len('http://'):] - host = host.rstrip('/') - if len(host) >= 256: return host - S = samclasses.BaseSession(samaddr) - ans = S._namelookup(host) - S.close() - return ans - -# -------------------------------------------------- -# End of File -# -------------------------------------------------- diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/SocketServer.py i2p-0.9.50/apps/sam/python/src/i2p/SocketServer.py --- i2p-0.9.49/apps/sam/python/src/i2p/SocketServer.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/SocketServer.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,72 +0,0 @@ - -""" -Emulation of Python SocketServer module using I2P sockets. - -The Python module is described at -http://www.python.org/doc/current/lib/module-SocketServer.html - -""" - -# By aum. - -# Hack to keep Python from importing from current directory: -# Use pylib package, then use = signs instead of from x import y. -import pylib -SocketServer = pylib.SocketServer - -import i2p.socket -class BaseServer(SocketServer.BaseServer): - pass -class TCPServer(SocketServer.TCPServer, BaseServer): - - socket_type = i2p.socket.SOCK_STREAM - - def __init__(self, session, RequestHandlerClass): - """ - Constructor. May be extended, do not override. - - The 'session' argument indicates the SAM session - name that should be used for the server. See module - i2p.socket for details on SAM sessions. - """ - BaseServer.__init__(self, session, RequestHandlerClass) - - #self.socket = socket.socket(self.address_family, - # self.socket_type) - self.session = session - self.socket = i2p.socket.socket(session, self.socket_type) - - self.server_bind() - self.server_activate() - -class UDPServer(TCPServer, SocketServer.UDPServer): - pass - -class ForkingMixIn(SocketServer.ForkingMixIn): - pass - -class ThreadingMixIn(SocketServer.ThreadingMixIn): - pass - -class ForkingUDPServer(ForkingMixIn, UDPServer): - pass - -class ForkingTCPServer(ForkingMixIn, TCPServer): - pass - -class ThreadingUDPServer(ThreadingMixIn, UDPServer): - pass - -class ThreadingTCPServer(ThreadingMixIn, TCPServer): - pass - -class BaseRequestHandler(SocketServer.BaseRequestHandler): - pass - -class StreamRequestHandler(SocketServer.StreamRequestHandler): - pass - -class DatagramRequestHandler(SocketServer.DatagramRequestHandler): - pass - - diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/test/readme.txt i2p-0.9.50/apps/sam/python/src/i2p/test/readme.txt --- i2p-0.9.49/apps/sam/python/src/i2p/test/readme.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/test/readme.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,6 +0,0 @@ - -Unit tests for I2P Python interface. - -Note that these aren't all unit tests yet. - -Some are demos, some require manual intervention. diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/test/test_eep.py i2p-0.9.50/apps/sam/python/src/i2p/test/test_eep.py --- i2p-0.9.49/apps/sam/python/src/i2p/test/test_eep.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/test/test_eep.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,37 +0,0 @@ - -# ----------------------------------------------------- -# test_eep.py: Unit tests for eep.py. -# ----------------------------------------------------- - -# Make sure we can import i2p -import sys; sys.path += ['../../'] - -import traceback, sys -from i2p import eep - -def verify_html(s): - """Raise an error if s does not end with """ - assert s.strip().lower()[-7:] == '' - -def eepget_test(): - try: - verify_html(eep.urlget('http://duck.i2p/index.html')) - verify_html(eep.urlget('http://duck.i2p/')) - verify_html(eep.urlget('http://duck.i2p')) - verify_html(eep.urlget('duck.i2p/')) - verify_html(eep.urlget('duck.i2p')) - except Exception, e: - print 'Unit test failed for eepget' - print "Note that urllib2.urlopen uses IE's proxy settings " + \ - "in Windows." - print "This may cause " + \ - "urllib2.urlopen('http://www.google.com/') to fail." - traceback.print_exc(); sys.exit() - print 'eepget: OK' - -def test(): - eepget_test() - -if __name__ == '__main__': - print 'Testing:' - test() diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/test/test_samclasses.py i2p-0.9.50/apps/sam/python/src/i2p/test/test_samclasses.py --- i2p-0.9.49/apps/sam/python/src/i2p/test/test_samclasses.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/test/test_samclasses.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,433 +0,0 @@ - -# ----------------------------------------------------- -# test_samclasses.py: Unit tests for samclasses.py. -# ----------------------------------------------------- - -# Make sure we can import i2p -import sys; sys.path += ['../../'] - -import traceback, time, thread, threading, random -from i2p import eep, socket, samclasses - -def test_passed(s, msg='OK'): - """Notify user that the given unit test passed.""" - print ' ' + (s + ':').ljust(50) + msg - -def verify_html(s): - """Raise an error if s does not end with """ - assert s.strip().lower()[-7:] == '' - -def raw_test1(): - """Unit test for samclasses.RawSession.""" - - try: - C = samclasses.RawSession('Carol') - D = samclasses.RawSession('Dave') - - C.send('Hello!', D.dest) - D.send('Hi C!', C.dest) - - (packet, addr) = C.recv(1000) - assert packet == 'Hi C!' - (packet, addr) = D.recv(1000) - assert packet == 'Hello!' - C.close() - D.close() - except: - print 'Unit test failed for samclasses.RawSession' - traceback.print_exc(); sys.exit() - test_passed('samclasses.RawSession') - -def datagram_test1(): - """Unit test for samclasses.DatagramSession.""" - - try: - C = samclasses.DatagramSession('Carol') - D = samclasses.DatagramSession('Dave') - - C.send('Hello!', D.dest) - D.send('Hi C!', C.dest) - - (packet, remotedest) = C.recv(1000) - assert str(packet) == 'Hi C!' and remotedest == D.dest - (packet, remotedest) = D.recv(1000) - assert str(packet) == 'Hello!' and remotedest == C.dest - C.close() - D.close() - except: - print 'Unit test failed for samclasses.DatagramSession' - traceback.print_exc(); sys.exit() - test_passed('samclasses.DatagramSession') - -def stream_readline(S): - """Read a line, with a \r\n newline, including trailing \r\n.""" - ans = [] - while True: - c = S.recv(1) - if c == '': break - if c == '\n': break - ans += [c] - return ''.join(ans) - -def stream_http_get(S, dest): - """Get contents of http://dest/ via HTTP/1.0 and - samclasses.StreamSession S.""" - C = S.connect(dest) - - C.send('GET / HTTP/1.0\r\n\r\n') - - while True: - line = stream_readline(C).strip() - if line.find('Content-Length: ') == 0: - clen = int(line.split()[1]) - if line == '': break - - s = C.recv(clen, timeout=None) - time.sleep(2.0) - C.close() - return s - -def stream_test1(): - """Unit test for samclasses.StreamSession.connect.""" - - try: - dest = socket.resolve('duck.i2p') - S = samclasses.StreamSession('Bob') - verify_html(stream_http_get(S, dest)) - verify_html(stream_http_get(S, dest)) - verify_html(stream_http_get(S, dest)) - S.close() - - except: - print 'Unit test failed for samclasses.StreamSession' - traceback.print_exc(); sys.exit() - test_passed('samclasses.StreamSession.connect') - -def stream_test2(): - """Unit test for samclasses.StreamSession.accept.""" - global __server_done, __client_done, __err - __server_done = False - __client_done = False - __err = None - - S = samclasses.StreamSession('Bob') - S.listen(10) - msg = 'Hello!' - - def serve(): - try: - # Serve 3 connections, then quit. - for i in range(3): - C = S.accept() # Get a connection. - req = stream_readline(C) # Read HTTP request. - - s = msg # Message to send back - - C.send('HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n' + - 'Content-Length: ' + str(int(len(s))) + '\r\n\r\n' + s) - - if i % 2 == 0: C.close() # Close connection - S.close() - except Exception, e: - global __err - __err = e - global __server_done - __server_done = True - - thread.start_new_thread(serve, ()) - # Wait for accept to kick in (should work without). - time.sleep(2.0) - - def client(): - try: - S2 = samclasses.StreamSession('Carol') - # Get / on server three times. - assert stream_http_get(S2, S.dest) == msg - assert stream_http_get(S2, S.dest) == msg - assert stream_http_get(S2, S.dest) == msg - S2.close() - except Exception, e: - global __err - __err = e - global __client_done - __client_done = True - - thread.start_new_thread(client, ()) - - while not (__client_done and __server_done): time.sleep(0.01) - - if __err != None: - print 'Unit test failed for samclasses.StreamSession.accept' - raise __err - test_passed('samclasses.StreamSession.accept') - -def multithread_packet_test(raw=True): - """If raw: Multithreaded unit test for samclasses.RawSession. - Not raw: Multithreaded unit test for samclasses.DatagramSession. - """ - - try: - multithread_wait_time = 200.0 - may_need_increase = False - - if raw: - C = samclasses.RawSession('Carol', in_depth=0, out_depth=0) - D = samclasses.RawSession('Dave', in_depth=0, out_depth=0) - else: - C = samclasses.DatagramSession('Carol',in_depth=0,out_depth=0) - D = samclasses.DatagramSession('Dave',in_depth=0,out_depth=0) - - global C_recv, D_recv, C_got, D_got, __lock - C_recv = [] # Packets C *should* receive - D_recv = [] # Packets D *should* receive - C_got = [] # Packets C actually got - D_got = [] # Packets D actually got - - n = 50 # Create n threads - m = 40 # Each thread sends m packets - - global __done_count - __done_count = 0 - __lock = threading.Lock() - - # Use C and D to send and read in many different threads. - def f(): - # This code is run in each separate thread - global C_recv, D_recv, C_got, D_got, __lock, __done_count - for i in range(m): - # Random binary string of length 2-80. - index_list = range(random.randrange(2, 80)) - s = ''.join([chr(random.randrange(256)) for j in index_list]) - if random.randrange(2) == 0: - # Send packet from C to D, and log it. - C.send(s, D.dest) - __lock.acquire() - D_recv += [s] - __lock.release() - else: - # Send packet from D to C, and log it. - D.send(s, C.dest) - __lock.acquire() - C_recv += [s] - __lock.release() - time.sleep(0.01*random.uniform(0.0,1.0)) - # Read any available packets. - try: (p, fromaddr) = C.recv(timeout=0.0) - except socket.BlockError: p = None - if p != None and not raw: assert fromaddr == D.dest - - __lock.acquire() - if p != None: C_got += [p] - __lock.release() - - try: (p, fromaddr) = D.recv(timeout=0.0) - except socket.BlockError: p = None - if p != None and not raw: assert fromaddr == C.dest - - __lock.acquire() - if p != None: D_got += [p] - __lock.release() - - __lock.acquire() - __done_count += 1 - __lock.release() - - # Create n threads. - for i in range(n): - threading.Thread(target=f).start() - - # Wait for them to finish. - while __done_count < n: time.sleep(0.01) - - # Read any left-over received packets. - end_time = time.time() + multithread_wait_time - while time.time() < end_time: - # Read any available packets. - try: (p, fromaddr) = C.recv(timeout=0.0) - except socket.BlockError: p = None - if p != None and not raw: assert fromaddr == D.dest - - if p != None: C_got += [p] - - try: (p, fromaddr) = D.recv(timeout=0.0) - except socket.BlockError: p = None - if p != None and not raw: assert fromaddr == C.dest - - if p != None: D_got += [p] - if len(C_got) == len(C_recv) and len(D_got) == len(D_recv): - break - - if time.time() >= end_time: - may_need_increase = True - - C_got.sort() - D_got.sort() - C_recv.sort() - D_recv.sort() - assert C_got == C_recv - assert D_got == D_recv - - C.close() - D.close() - except: - if raw: - print 'Unit test failed for samclasses.RawSession ' + \ - '(multithreaded).' - print 'Raw packets are not reliable.' - else: - print 'Unit test failed for samclasses.DatagramSession ' + \ - '(multithreaded).' - print 'Datagram packets are not reliable.' - - if may_need_increase: - print 'Try increasing multithread_wait_time.' - - traceback.print_exc(); sys.exit() - if raw: - test_passed('samclasses.RawSession (multithreaded)') - else: - test_passed('samclasses.DatagramSession (multithreaded)') - - - -def multithread_stream_test(): - """Multithreaded unit test for samclasses.StreamSession.""" - - try: - multithread_wait_time = 200.0 - may_need_increase = False - - C = samclasses.StreamSession('Carol', in_depth=0, out_depth=0) - D = samclasses.StreamSession('Dave', in_depth=0, out_depth=0) - C.listen(10) - D.listen(10) - - Cout = C.connect(D.dest) - Dout = D.connect(C.dest) - Cin = C.accept() - Din = D.accept() - - global C_recv, D_recv, C_got, D_got, __lock - C_recv = [] # String data C *should* receive - D_recv = [] # String data D *should* receive - C_got = [] # String data C actually got - D_got = [] # String data D actually got - - n = 50 # Create n threads - m = 40 # Each thread sends m strings - - global __done_count - __done_count = 0 - __lock = threading.Lock() - - # Use C and D to send and read in many different threads. - def f(): - # This code is run in each separate thread - global C_recv, D_recv, C_got, D_got, __lock, __done_count - for i in range(m): - # Random binary string of length 2-80. - index_list = range(random.randrange(2, 80)) - s = ''.join([chr(random.randrange(256)) for j in index_list]) - if random.randrange(2) == 0: - # Send packet from C to D, and log it. - __lock.acquire() - Cout.send(s) - D_recv += [s] - __lock.release() - else: - # Send packet from D to C, and log it. - __lock.acquire() - Dout.send(s) - C_recv += [s] - __lock.release() - time.sleep(0.01*random.uniform(0.0,1.0)) - # Read any available string data, non-blocking. - - __lock.acquire() - try: p = Cin.recv(100000, timeout=0.0) - except socket.BlockError: p = None - if p != None: C_got += [p] - __lock.release() - - __lock.acquire() - try: p = Din.recv(100000, timeout=0.0) - except socket.BlockError: p = None - if p != None: D_got += [p] - __lock.release() - - __lock.acquire() - __done_count += 1 - __lock.release() - - # Create n threads. - for i in range(n): - threading.Thread(target=f).start() - - # Wait for them to finish. - while __done_count < n: time.sleep(0.01) - - # Read any left-over received string data. - end_time = time.time() + multithread_wait_time - while time.time() < end_time: - # Read any available string data, non-blocking. - try: p = Cin.recv(100000, timeout=0.0) - except socket.BlockError: p = None - if p != None: C_got += [p] - - try: p = Din.recv(100000, timeout=0.0) - except socket.BlockError: p = None - if p != None: D_got += [p] - - if len(''.join(C_got)) == len(''.join(C_recv)) and \ - len(''.join(D_got)) == len(''.join(D_recv)): - break - - if time.time() >= end_time: - may_need_increase = True - - C_got = ''.join(C_got) - D_got = ''.join(D_got) - C_recv = ''.join(C_recv) - D_recv = ''.join(D_recv) - assert C_got == C_recv - assert D_got == D_recv - - Cin.close() - Din.close() - Cout.close() - Dout.close() - C.close() - D.close() - except: - print 'Unit test failed for samclasses.StreamSession ' + \ - '(multithreaded).' - - if may_need_increase: - print 'Try increasing multithread_wait_time.' - - traceback.print_exc(); sys.exit() - test_passed('samclasses.StreamSession (multithreaded)') - - -def test(): - print 'Tests may take several minutes each.' - print 'If the network is unreliable, tests will fail.' - print 'A test only needs to pass once to be considered successful.' - print - print 'Testing:' - - raw_test1() - datagram_test1() - stream_test1() - stream_test2() - multithread_packet_test(raw=True) - multithread_stream_test() - - # Note: The datagram unit test fails, but it's apparently I2P's - # fault (the code is the same as for raw packets, and the SAM - # bridge is sent all the relevant data). - # Code: multithread_packet_test(raw=False) - -if __name__ == '__main__': - test() - diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/test/test_select.py i2p-0.9.50/apps/sam/python/src/i2p/test/test_select.py --- i2p-0.9.49/apps/sam/python/src/i2p/test/test_select.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/test/test_select.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,109 +0,0 @@ - -# ----------------------------------------------------- -# test_select.py: Unit tests for select.py. -# ----------------------------------------------------- - -# Make sure we can import i2p -import sys; sys.path += ['../../'] - -import time - -import traceback, sys -from i2p import socket, select -import i2p.socket -import socket as pysocket - -def minitest_select(rans, wans, eans, timeout, - f1=None, f4=None, c1=None, c4=None): - """Mini-unit test for select (Python and I2P sockets). - Calls f1() on socket S1, f4() on socket S4, uses select() - timeout 'timeout'. rans, wans, and eans should be lists - containing indexes 1...6 of the sockets defined below. The - result of i2p.select.select() will be verified against these - lists. After this, calls c1() on S1, and c4() on S4.""" - S1 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_STREAM) - S2 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_DGRAM) - S3 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_RAW) - - kw = {'in_depth':0, 'out_depth':0} - S4 = socket.socket('Fella', socket.SOCK_STREAM, **kw) - S5 = socket.socket('Boar', socket.SOCK_DGRAM, **kw) - S6 = socket.socket('Gehka', socket.SOCK_RAW, **kw) - - if f1: f1(S1) - if f4: f4(S4) - - L = [S1, S2, S3, S4, S5, S6] - - start = time.time() - ans = select.select(L, L, L, timeout) - ans1 = select.select(L, [], [], timeout) - ans2 = select.select([], L, [], timeout) - ans3 = select.select([], [], L, timeout) - end = time.time() - T = end - start - - ans = [[L.index(x) + 1 for x in ans [i]] for i in range(3)] - ans1 = [[L.index(x) + 1 for x in ans1[i]] for i in range(3)] - ans2 = [[L.index(x) + 1 for x in ans2[i]] for i in range(3)] - ans3 = [[L.index(x) + 1 for x in ans3[i]] for i in range(3)] - - assert ans1[0] == rans - assert ans2[1] == wans - assert ans3[2] == eans - assert ans == [rans, wans, eans] - assert T < 4 * timeout + 0.1 - - if c1: c1(S1) - if c4: c4(S4) - -def test_select(): - """Unit test for select (Python and I2P sockets).""" - - def connect1(S): - """Connect regular Python socket to Google.""" - ip = pysocket.gethostbyname('www.google.com') - S.connect((ip, 80)) - - def connect4(S): - """Connect I2P Python socket to duck.i2p.""" - S.connect('duck.i2p') - - def full1(S): - """Connect regular Python socket to Google, and send.""" - connect1(S) - S.sendall('GET / HTTP/1.0\r\n\r\n') - S.recv(1) - - def full4(S): - """Connect I2P Python socket to duck.i2p, and send.""" - connect4(S) - S.sendall('GET / HTTP/1.0\r\n\r\n') - S.recv(1) - # Peek twice (make sure peek code isn't causing problems). - S.recv(1, i2p.socket.MSG_PEEK | i2p.socket.MSG_DONTWAIT) - S.recv(1, i2p.socket.MSG_PEEK | i2p.socket.MSG_DONTWAIT) - - def check(S): - """Verify that three chars recv()d are 'TTP'.""" - assert S.recv(3) == 'TTP' - - try: - for t in [0.0, 1.0]: - minitest_select([], [2, 3, 5, 6], [], t) - minitest_select([], [1, 2, 3, 4, 5, 6], [], t, - f1=connect1, f4=connect4) - minitest_select([], [1, 2, 3, 5, 6], [], t, - f1=connect1) - minitest_select([], [2, 3, 4, 5, 6], [], t, - f4=connect4) - minitest_select([1, 4], [1, 2, 3, 4, 5, 6], [], t, - f1=full1, f4=full4, c1=check, c4=check) - except: - print 'Unit test failed for i2p.select.select().' - traceback.print_exc(); sys.exit() - print 'i2p.select.select(): OK' - - -if __name__ == '__main__': - test_select() diff -Nru i2p-0.9.49/apps/sam/python/src/i2p/test/test_socket.py i2p-0.9.50/apps/sam/python/src/i2p/test/test_socket.py --- i2p-0.9.49/apps/sam/python/src/i2p/test/test_socket.py 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/src/i2p/test/test_socket.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,427 +0,0 @@ - -# -------------------------------------------------------- -# test_socket.py: Unit tests for socket, select. -# -------------------------------------------------------- - -# Make sure we can import i2p -import sys; sys.path += ['../../'] - -import traceback, time, thread, threading, random, copy -from i2p import socket, select - -def test_passed(s, msg='OK'): - """Notify user that the given unit test passed.""" - print ' ' + (s + ':').ljust(50) + msg - -def verify_html(s): - """Raise an error if s does not end with """ - assert s.strip().lower()[-7:] == '
<%=intl._t("Routers in the same family share a family key.")%> -<%=intl._t("To join an existing family, import the private key you exported from a router in the family.")%> -<%=intl._t("To start a new family, enter a family name.")%> -
<% /* note to translators - both parameters are URLs */ %><%=intl._t("Please report bugs on {0} or {1}.", - "trac.i2p2.i2p", - "trac.i2p2.de")%> + "git.idk.i2p", + "i2pgit.org")%>
<%=intl._t("Please include this information in bug reports")%>:
I2P version: <%=net.i2p.router.RouterVersion.FULL_VERSION%> +API version: <%=net.i2p.CoreVersion.PUBLISHED_VERSION%> Java version: <%=System.getProperty("java.vendor")%> <%=System.getProperty("java.version")%> (<%=System.getProperty("java.runtime.name")%> <%=System.getProperty("java.runtime.version")%>) diff -Nru i2p-0.9.49/apps/routerconsole/jsp/help-faq.jsi i2p-0.9.50/apps/routerconsole/jsp/help-faq.jsi --- i2p-0.9.49/apps/routerconsole/jsp/help-faq.jsi 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/help-faq.jsi 2021-05-19 12:11:56.000000000 +0000 @@ -23,8 +23,7 @@ <%=intl._t("You may wish to add one or two to your subscription list.")%>
http://stats.i2p/cgi-bin/newhosts.txt
http://no.i2p/export/alive-hosts.txt
http://identiguy.i2p/hosts.txt
http://notbob.i2p/hosts.txt
<%=intl._t("Note that subscribing to a hosts.txt service is an act of trust, as a malicious subscription could give you incorrect addresses, so be careful subscribing to lists from unknown sources.")%> diff -Nru i2p-0.9.49/apps/routerconsole/jsp/help.jsp i2p-0.9.50/apps/routerconsole/jsp/help.jsp --- i2p-0.9.49/apps/routerconsole/jsp/help.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/help.jsp 2021-05-19 12:11:56.000000000 +0000 @@ -1,5 +1,4 @@ <%@page contentType="text/html"%> -<%@page trimDirectiveWhitespaces="true"%> <%@page pageEncoding="UTF-8"%>
<%=intl._t("While I2P will work fine behind most firewalls, your speeds and network integration will generally improve if the I2P port is forwarded for both UDP and TCP.")%> <%=intl._t("If you think you have opened up your firewall and I2P still thinks you are firewalled, remember that you may have multiple firewalls, for example both software packages and external hardware routers.")%> diff -Nru i2p-0.9.49/apps/routerconsole/jsp/logs.jsp i2p-0.9.50/apps/routerconsole/jsp/logs.jsp --- i2p-0.9.49/apps/routerconsole/jsp/logs.jsp 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/routerconsole/jsp/logs.jsp 2021-05-19 12:11:56.000000000 +0000 @@ -16,8 +16,8 @@ <%=intl._t("Note that system information, log timestamps, and log messages may provide clues to your location; please review everything you include in a bug report.")%> <% /* note to translators - both parameters are URLs */ %><%=intl._t("Please report bugs on {0} or {1}.", - "trac.i2p2.i2p", - "trac.i2p2.de")%> + "git.idk.i2p", + "i2pgit.org")%>
<%=intl._t("Let's check your internet connection!")%> @@ -179,9 +179,6 @@ } else if (ipg == 3) { // Bandwidth test in progress (w/ AJAX) %> - -
From Python-I2P. - - -
-The eeproxy is usually available at http://127.0.0.1:4444/. - -
-
- - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.BaseHTTPServer.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,91 +0,0 @@ - -
- -
-The Python module is described at http://www.python.org/doc/current/lib/module-BaseHTTPServer.html - -
-To get a server going, use: - -
->>> from i2p import BaseHTTPServer ->>> BaseHTTPServer.test(). -
-Consult the documentation for function test() to change basic server settings, such as the session name. - -
-A fully customizable example: - -
->>> from i2p import BaseHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() -
-class BaseHTTPRequestHandler -
-Same interface as Python class BaseHTTPServer.BaseHTTPRequestHandler. -
-Same interface as Python class BaseHTTPServer.HTTPServer. -
-test(HandlerClass=BaseHTTPRequestHandler, ServerClass=HTTPServer, protocol='HTTP/1.0', session='mytestxxx.i2p') -
-Test the HTTP request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single command -line argument is given, the argument is used instead as the SAM session name. -
i2p.CGIHTTPServer
-The Python module is described at http://www.python.org/doc/current/lib/module-CGIHTTPServer.html - -
->>> from i2p import CGIHTTPServer ->>> CGIHTTPServer.test(). -
->>> from i2p import BaseHTTPServer, CGIHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() -
-class CGIHTTPRequestHandler -
-Same interface as Python class CGIHTTPServer.CGIHTTPRequestHandler. -
- -test(HandlerClass=CGIHTTPRequestHandler, -ServerClass=i2p.BaseHTTPServer.HTTPServer, -session='mytestxxx.i2p') -
-Test the HTTP CGI request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single -command line argument is given, the argument is used instead as the SAM session -name. -
i2p.eep
-With this module, a program can easily download eepsites. - -
-urlopen(url, eepaddr='127.0.0.1:4444') -
Like urllib2.urlopen(url), but only works for eep-sites. - Example: f = urlopen('http://duck.i2p/index.html') - -
Get contents of an eepsite. - Example: urlget('http://duck.i2p/'). -
- - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,59 +0,0 @@ - -
i2p
-It contains the following modules: - -
i2p.BaseHTTPServer (Emulate Python BaseHTTPServer module) - i2p.CGIHTTPServer (Emulate Python CGIHTTPServer module) - i2p.eep (Retrieve eepsites) - i2p.router (Manage the I2P router) - i2p.select (Emulate Python select module) - i2p.SimpleHTTPServer (Emulate Python SimpleHTTPServer module) - i2p.socket (Send and receive across the I2P network) - i2p.SocketServer (Emulate Python SocketServer module) - i2p.tunnel (Exchange data between I2P and regular sockets) - -
Base class for all I2P errors. -
-class RouterError(Error): -
Could not connect to router. -
i2p.router
-check(dir=None) -
- Checks whether a locally installed router is running. Does - nothing if successful, otherwise raises i2p.RouterError. - - An I2P installation is located by using find(dir). - The router.config file is parsed for 'router.adminPort'. - This port is queried to determine whether the router is - running. -
- - Find the absolute path to a locally installed I2P router. - - An I2P installation is located by looking in the - dir argument given to the function, then in the environment - I2P, then in PATH. It looks for startRouter.sh or - startRouter.bat. Raises ValueError if an I2P installation - could not be located. -
- Start a locally installed I2P router. Does nothing if - the router has already been started. - - An I2P installation is located by using find(dir). - - If hidden is True, do not show a terminal for the router. -
- Stop a locally installed I2P router, if it was started by - the current Python program. If force is True, stop the - router even if it was started by another process. Do nothing - if force is False and the router was started by another program. - - The file 'router.config' is located using the same search - process used for find(dir). It is parsed for - 'router.shutdownPassword' and 'router.adminPort'. The - router is shut down through the admin port. - - Raises i2p.RouterError if the I2P router is running but cannot - be stopped. You must uncomment the - 'router.shutdownPassword' line for this command to work. -
- - diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/i2p.select.html i2p-0.9.50/apps/sam/python/doc/guide/i2p.select.html --- i2p-0.9.49/apps/sam/python/doc/guide/i2p.select.html 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/i2p.select.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,60 +0,0 @@ - -
i2p.select
select
-With this module, a program can perform select and poll commands on traditional and I2P sockets. - -
-poll() -
Returns a polling object. Works on SAM sockets and Python sockets. - See select.poll() in the Python library for more information. -
-select(readlist, writelist, errlist, timeout=None) -
Performs a select call. Works on SAM sockets and Python sockets. - See select.select() in the Python library for more information. -
-Polling flags - -
- POLLIN = 1 - POLLOUT = 4 - POLLERR = 8 - POLLHUP = 16 - POLLNVAL = 32 - POLLPRI = 1 -
-The Python module is described at http://www.python.org/doc/current/lib/module-SimpleHTTPServer.html - -
->>> from i2p import SimpleHTTPServer ->>> SimpleHTTPServer.test(). -
->>> from i2p import BaseHTTPServer, SimpleHTTPServer ->>> session = "mytestxxx.i2p" # SAM session name ->>> class MyServer(BaseHTTPServer.HTTPServer): pass ->>> class MyRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): pass ->>> httpd = MyServer(session, MyRequestHandler) ->>> httpd.socket.dest -(Base64 Destination of server) ->>> httpd.serve_forever() -
-class SimpleHTTPRequestHandler -
-Same interface as Python class SimpleHTTPServer.SimpleHTTPRequestHandler. -
- -test(HandlerClass=SimpleHTTPRequestHandler, ServerClass= i2p.BaseHTTPServer.HTTPServer, session='mytestxxx.i2p') -
-Test the HTTP simple request handler class. -This runs an I2P TCP server under SAM session 'session'. If a single command -line argument is given, the argument is used instead as the SAM session name. -
i2p.socket
socket
-With this module, a program can send stream data, datagrams, and raw packets across the I2P network. - -
-class socket(session, type, samaddr='127.0.0.1:7656', **kwargs) -
- Create a new socket. Argument session should be a session - name -- if the name has not yet been used, an I2P - Destination will be created for it, otherwise, the - existing Destination will be re-used. An empty session - string causes a transient session to be created. Argument - type is one of SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - I2P configuration keyword arguments: - - - in_depth - depth of incoming tunnel (default 2) - - out_depth - depth of outgoing tunnel (default 2) - - A single session may be shared by more than one socket, if - the sockets are the same type, and if the sockets are - created within the same Python process. The socket - objects are multithread-safe. - - Examples: - >>> a = i2p.socket('Alice', i2p.SOCK_STREAM) - >>> b = i2p.socket('Bob', i2p.SOCK_DGRAM, - in_depth=2, out_depth=5) - - The created object behaves identically to a socket from - module socket, with the following exceptions: - - * I2P Destinations are used as address arguments [1]. - * bind is a no-op: sockets are always bound. - * send* methods send all data and are non-blocking. - - A given session name can only be open in a single Python - program at a time. If you need to overcome this - limitation, consider patching I2P. - - [1]. Alternatively, a host name can be used as an address. - It will be resolved using hosts.txt. - -
For details on how to use socket objects, see - http://www.python.org/doc/current/lib/socket-objects.html -
See the examples directory for code examples. -
dest - Local I2P Destination of socket - session - Session name - type - Socket type: SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. -
-The class socket defines the following methods: - -
-accept(self) -
- Accept an incoming connection. The socket must be type SOCK_STREAM, and - listen() must be called prior to this command. The return value is (conn, - remotedest), where conn is a new socket object made for the connection, and - remotedest is the remote Destination from which the connection was made. - - Example: - - >>> from i2p import socket - >>> s = socket.socket('Alice', socket.SOCK_STREAM) - >>> s.listen(10) - - This prepares the server. Now accept an incoming connection: - - >>> c, remotedest = s.accept() - >>> c.send('hello world!') - - If accept() is called on a socket that is in non-blocking mode or has a - timeout, i2p.socket.BlockError or i2p.socket.Timeout may be raised. This - indicates that no incoming connection is currently available. - -
- Does nothing. Provided for compatibility with the Python socket command - bind(), which binds a server to a port. -
- Closes the socket. It is an error to call any method other than recv() or - recvfrom() on a closed socket. For streams, the receive methods return data - that was received prior to the closing of the socket. For datagram and raw - sockets, the receive methods cannot be used on a closed socket. -
- Connect to a remote dest, identified in local SAM bridge's hosts file as host - 'address'. - - For example: - - >>> s.connect('duck.i2p') - - Alternatively, you can use a full base64 Destination: - Example: - - >>> s.connect('238797sdfh2k34kjh....AAAA') - - If connect() is called on a socket that is in non-blocking mode or has a - timeout, i2p.socket.BlockError or i2p.socket.Timeout may be raised. This - indicates that the connection is still being initiated. Use i2p.select.select() - to determine when the connection is ready. -
- Like connect(), but return any error that is raised. Returns None if no error - is raised. -
- Get the remote Destination associated with the socket. This is equivalent to - s.remotedest, and is provided for compatibility with the Python socket module. -
- Get the local Destination associated with the socket. This is equivalent to - s.dest, and is provided for compatibility with the Python socket module. -
- Get the timeout value. - -
- Listen for connections made to the socket. This method must be called before - accept(). The backlog argument specifies the maximum number of queued incoming - connections. -
- Return a file object for the socket. See socket.makefile() in the Python - documentation for more information. -
- Receive string data from the socket. - - The maximum amount of data to be received is given by bufsize. If bufsize is - zero, this function returns an empty string immediately. If bufsize is nonzero, - this function blocks until at least one character is available for reading. If - the socket has been closed, an empty string is returned as an end of file - indicator. - - If recv() is called on a socket that is in non-blocking mode or has a timeout, - i2p.socket.BlockError or i2p.socket.Timeout will be raised if data is not - available within the given timeframe. - - For a datagram or raw socket, the first bufsize characters of the packet are - read, and the remainder of the packet is discarded. To read the entire packet, - use bufsize = -1. - - For datagram and raw sockets, the packet may originate from any Destination. - Use recvfrom() with datagrams to determine the Destination from which the - packet was received. - - The flags argument can be a bitwise OR of MSG_PEEK, MSG_WAITALL, and/or - MSG_DONTWAIT. MSG_PEEK indicates that any data read should not be removed from - the socket's incoming buffer. MSG_WAITALL indicates to wait for exactly bufsize - characters or an error. MSG_DONTWAIT indicates that the recv() command should - not block execution. -
- Like recv(), but returns a tuple (data, remoteaddr), where data is the string - data received, and remoteaddr is the remote Destination. -
- Sends string data to a remote Destination. - - For a stream, connect() must be called prior to send(). Once close() is called, - no further data can be sent, and the stream cannot be re-opened. - - For datagram and raw sockets, connect() only specifies a Destination to which - packets are sent to. send() will then send a packet to the given Destination. - connect() can be used multiple times. - - The send() command never blocks execution. The flags argument is ignored. - -
- Identical to send(). -
- Send a packet to the given Destination. - - Only valid for datagram and raw sockets. The address argument should be either - a name from the hosts file, or a base64 Destination. - - The sendto() command never blocks execution. The flags argument is ignored. -
- Set blocking or non-blocking mode for the socket. - - If flag is True, any method called on the socket will hang until the method has - completed. If flag is False, all methods will raise i2p.socket.BlockError() if - they cannot complete instantly. - - s.setblocking(False) is equivalent to s.settimeout(0); s.setblocking(True) is - equivalent to s.settimeout(None). -
- Set a timeout for the socket. - - The value argument should be a timeout value in seconds, or None. None is - equivalent to an infinite timeout. - - A socket operation will raise a i2p.socket.Timeout if the operation cannot - complete within in the specified time limit. -
-Functions defined in module i2p.socket: - -
-resolve(host, samaddr='127.0.0.1:7656') -
Resolve I2P host name --> I2P Destination. - Returns the same string if host is already a Destination. -
-class Error(i2p.Error) -
- Base class for all SAM errors. -
- Socket call would have blocked. -
- A command was used on a socket that closed gracefully. -
- - Network error occurred within I2P. - - The error object is a 2-tuple: (errtag, errdesc). - errtag is a SAM error string, - errdesc is a human readable error description. -
-Socket types -
- SOCK_STREAM = 1 - SOCK_DGRAM = 2 - SOCK_RAW = 3 - -
- MAX_DGRAM = 31744 # Maximum size for datagram packet - MAX_RAW = 32768 # Maximum size for raw packet -
- MSG_DONTWAIT = 128 # Don't block - MSG_PEEK = 2 # Peek at incoming data - MSG_WAITALL = 64 # Wait for all data or error -
-The Python module is described at http://www.python.org/doc/current/lib/module-SocketServer.html - -
-BaseRequestHandler -BaseServer -DatagramRequestHandler -ForkingMixIn -ForkingTCPServer -ForkingUDPServer -StreamRequestHandler -TCPServer -ThreadingMixIn -ThreadingTCPServer -ThreadingUDPServer -UDPServer -
i2p.tunnel
-Tunnels allow stream sockets to be joined, so that connections to a listening socket are relayed to one or more sending sockets. This allows an ordinary web server to be exposed as an I2P Destination, or an I2P Destination to be bound as a local port, and so on. - -
-class Tunnel(self, receive, make_send, nconnect=-1, timeout=60.0) -
- A Tunnel relays connections from a 'receive' socket to one - or more 'send' sockets. The receive socket must be bound - and listening. For each incoming connection, a new send - socket is created by calling make_send(). Data is then - exchanged between the created streams until one socket is - closed. nconnect is the maximum number of simultaneous - connections (-1 for infinite), and timeout is the time that - a single connection can last for (None allows a connection - to last forever). - - Sockets must accept stream traffic and support the Python - socket interface. A separate daemonic thread is created to - manage the tunnel. For high performance, make_send() should - make a socket and connect in non-blocking mode (you should - catch and discard the i2p.socket.BlockError or socket.error - due to executing connect on a non-blocking socket). - - Security Note: - A firewall is needed to maintain the end user's anonymity. - An attacker could keep a tunnel socket open by pinging it - regularly. The accepted sockets from 'receive' must prevent - this by closing down eventually. - - Socket errors do not cause the Tunnel to shut down. -
-close() -
Close all connections made for this tunnel. -
-class TunnelServer(session, port, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) -
- Tunnels incoming SAM streams --> localhost:port. - - nconnect and timeout are the maximum number of connections - and maximum time per connection. All other arguments are - passed to i2p.socket.socket(). This call blocks until the - tunnel is ready. -
-TunnelServer properties: -
- - dest - I2P Destination of server. - session - Session name for server. -
-class TunnelClient(session, port, dest, samaddr='127.0.0.1:7656', nconnect=-1, timeout=None, **kwargs) -
- Derived from Tunnel. - Tunnels localhost:port --> I2P Destination dest. - - A session named 'session' is created locally, for purposes - of routing to 'dest'. nconnect and timeout are the maximum - number of connections and maximum time per connection. All - other arguments are passed to i2p.socket.socket(). This call - blocks until the tunnel is ready. - -
-TunnelClient properties: -
- dest - Local Destination used for routing. - remotedest - Remote Destination. - session - Session name for local Destination. -
-Install: - -
-python setup.py install -
-Use: - -
->>> from i2p import socket ->>> s = socket.socket('Alice', socket.SOCK_STREAM) ->>> s.connect('duck.i2p') ->>> s.send('GET / HTTP/1.0\r\n\r\n') ->>> s.recv(1000) -(HTTP response from duck.i2p) -
- -See the src/examples/ directory for more code examples. - -
-The following modules are available: - -
i2p (Container package) - i2p.BaseHTTPServer (Emulate Python BaseHTTPServer module) - i2p.CGIHTTPServer (Emulate Python CGIHTTPServer module) - i2p.eep (Retrieve eepsites) - i2p.router (Manage the I2P router) - i2p.select (Emulate Python select module) - i2p.SimpleHTTPServer (Emulate Python SimpleHTTPServer module) - i2p.socket (Send and receive across the I2P network) - i2p.SocketServer (Emulate Python SocketServer module) - i2p.tunnel (Exchange data between I2P and regular sockets) - -
-The protocol used for SAM is described in SAM 1.0. - -
-In practice, a SAM library is usually written, so that client applications do not need to use the low-level SAM commands. - -
- - - \ No newline at end of file diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/eeproxy.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/eeproxy.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/eeproxy.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/eeproxy.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,5 +0,0 @@ -Title: Eeproxy - -The '''Eeproxy''' is run by the I2P router. The proxy is normally used for web browsers, as a means of accessing eepsites. - -The eeproxy is usually available at http://127.0.0.1:4444/. diff -Nru i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt --- i2p-0.9.49/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt 2021-02-17 19:22:20.000000000 +0000 +++ i2p-0.9.50/apps/sam/python/doc/guide/wiki/i2p.BaseHTTPServer.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,49 +0,0 @@ -Title: User's Guide:i2p.BaseHTTPServer - -Emulates Python BaseHTTPServer module using I2P sockets. - -== Overview == - -The Python module is described at http://www.python.org/doc/current/lib/module-BaseHTTPServer.html - -To get a server going, use: - -
- Find the absolute path to a locally installed I2P router. - - An I2P installation is located by looking in the - dir argument given to the function, then in the environment - I2P, then in PATH. It looks for startRouter.sh or - startRouter.bat. Raises ValueError if an I2P installation - could not be located. -
i2p.sam
- Create a new socket. Argument session should be a session - name -- if the name has not yet been used, an I2P - Destination will be created for it, otherwise, the - existing Destination will be re-used. An empty session - string causes a transient session to be created. Argument - type is one of SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - I2P configuration keyword arguments: - - * in_depth - depth of incoming tunnel (default 2) - * out_depth - depth of outgoing tunnel (default 2) - - A single session may be shared by more than one socket, if - the sockets are the same type, and if the sockets are - created within the same Python process. The socket - objects are multithread-safe. - - Examples: - a = i2p.socket('Alice', i2p.SOCK_STREAM) - b = i2p.socket('Bob', i2p.SOCK_DGRAM, - in_depth=2, out_depth=5) - - The created object behaves identically to a socket from - module socket, with the following exceptions: - - * I2P Destinations are used as address arguments [1]. - * bind is a no-op: sockets are always bound. - * send* methods send all data and are non-blocking. - - A given session name can only be open in a single Python - program at a time. If you need to overcome this - limitation, consider patching I2P. - - [1]. Alternatively, a host name can be used as an address. - It will be resolved using hosts.txt. - - For details on how to use socket objects, see - http://www.python.org/doc/current/lib/socket-objects.html - - See the examples directory for code examples. -
- A Tunnel relays connections from a 'receive' socket to one - or more 'send' sockets. The receive socket must be bound - and listening. For each incoming connection, a new send - socket is created by calling make_send(). Data is then - exchanged between the created streams until one socket is - closed. nconnect is the maximum number of simultaneous - connections (-1 for infinite), and timeout is the time that - a single connection can last for (None allows a connection - to last forever). - - Sockets must accept stream traffic and support the Python - socket interface. A separate daemonic thread is created to - manage the tunnel. For high performance, make_send() should - make a socket and connect in non-blocking mode (you should - catch and discard the sam.BlockError or socket.error due to - executing connect on a non-blocking socket). - - Security Note: - A firewall is needed to maintain the end user's anonymity. - An attacker could keep a tunnel socket open by pinging it - regularly. The accepted sockets from 'receive' must prevent - this by closing down eventually. - - Socket errors do not cause the Tunnel to shut down. -
- Tunnels incoming SAM streams --> localhost:port. - - nconnect and timeout are the maximum number of connections - and maximum time per connection. All other arguments are - passed to sam.socket(). This call blocks until the tunnel - is ready. -
- dest - I2P Destination of server. - session - Session name for server. -
- Derived from Tunnel. - Tunnels localhost:port --> I2P Destination dest. - - A session named 'session' is created locally, for purposes - of routing to 'dest'. nconnect and timeout are the maximum - number of connections and maximum time per connection. All - other arguments are passed to sam.socket(). This call blocks - until the tunnel is ready. -
- Network error occurred within I2P. - - The error object is a 2-tuple: (errtag, errdesc). - errtag is a SAM error string, - errdesc is a human readable error description. -
- SOCK_STREAM = 1 - SOCK_DGRAM = 2 - SOCK_RAW = 3 -
- Create a new socket. Argument session should be a session - name -- if the name has not yet been used, an I2P - Destination will be created for it, otherwise, the - existing Destination will be re-used. An empty session - string causes a transient session to be created. Argument - type is one of SOCK_STREAM, SOCK_DGRAM, or SOCK_RAW. - - I2P configuration keyword arguments: - - - in_depth - depth of incoming tunnel (default 2) - - out_depth - depth of outgoing tunnel (default 2) - - A single session may be shared by more than one socket, if - the sockets are the same type, and if the sockets are - created within the same Python process. The socket - objects are multithread-safe. - - Examples: - >>> a = i2p.socket('Alice', i2p.SOCK_STREAM) - >>> b = i2p.socket('Bob', i2p.SOCK_DGRAM, - in_depth=2, out_depth=5) - - The created object behaves identically to a socket from - module socket, with the following exceptions: - - * I2P Destinations are used as address arguments [1]. - * bind is a no-op: sockets are always bound. - * send* methods send all data and are non-blocking. - - A given session name can only be open in a single Python - program at a time. If you need to overcome this - limitation, consider patching I2P. - - [1]. Alternatively, a host name can be used as an address. - It will be resolved using hosts.txt. -
- Accept an incoming connection. The socket must be type SOCK_STREAM, and - listen() must be called prior to this command. The return value is (conn, - remotedest), where conn is a new socket object made for the connection, and - remotedest is the remote Destination from which the connection was made. - - Example: - - >>> from i2p import socket - >>> s = socket.socket('Alice', socket.SOCK_STREAM) - >>> s.listen(10) - - This prepares the server. Now accept an incoming connection: - - >>> c, remotedest = s.accept() - >>> c.send('hello world!') - - If accept() is called on a socket that is in non-blocking mode or has a - timeout, i2p.socket.BlockError or i2p.socket.Timeout may be raised. This - indicates that no incoming connection is currently available. -
- Get the timeout value. -
- Sends string data to a remote Destination. - - For a stream, connect() must be called prior to send(). Once close() is called, - no further data can be sent, and the stream cannot be re-opened. - - For datagram and raw sockets, connect() only specifies a Destination to which - packets are sent to. send() will then send a packet to the given Destination. - connect() can be used multiple times. - - The send() command never blocks execution. The flags argument is ignored. -
- A Tunnel relays connections from a 'receive' socket to one - or more 'send' sockets. The receive socket must be bound - and listening. For each incoming connection, a new send - socket is created by calling make_send(). Data is then - exchanged between the created streams until one socket is - closed. nconnect is the maximum number of simultaneous - connections (-1 for infinite), and timeout is the time that - a single connection can last for (None allows a connection - to last forever). - - Sockets must accept stream traffic and support the Python - socket interface. A separate daemonic thread is created to - manage the tunnel. For high performance, make_send() should - make a socket and connect in non-blocking mode (you should - catch and discard the i2p.socket.BlockError or socket.error due to - executing connect on a non-blocking socket). - - Security Note: - A firewall is needed to maintain the end user's anonymity. - An attacker could keep a tunnel socket open by pinging it - regularly. The accepted sockets from 'receive' must prevent - this by closing down eventually. - - Socket errors do not cause the Tunnel to shut down. -
- Derived from Tunnel. - Tunnels localhost:port --> I2P Destination dest. - - A session named 'session' is created locally, for purposes - of routing to 'dest'. nconnect and timeout are the maximum - number of connections and maximum time per connection. All - other arguments are passed to i2p.socket.socket(). This call - blocks until the tunnel is ready. -