## net.i2p.i2ptunnel
Class I2PTunnelRunner

    java.lang.Object
      java.lang.Thread
          net.i2p.util.I2PThread
              net.i2p.util.I2PAppThread
                  net.i2p.i2ptunnel.I2PTunnelRunner

All Implemented Interfaces:
  Runnable, I2PSocket.SocketErrorListener

Direct Known Subclasses:
  I2PTunnelHTTPClientRunner

    public class I2PTunnelRunner

extends I2PAppThread
implements I2PSocket.SocketErrorListener

Nested Class Summary

Nested classes/interfaces inherited from class net.i2p.util.I2PThread
`I2PThread.OOMEventListener`

Nested classes/interfaces inherited from class java.lang.Thread
`Thread.State, Thread.UncaughtExceptionHandler`

Field Summary
`(package private) boolean` `finished`
`(package private) Object` `finishLock`
`(package private) byte[]` `initialI2PData`
`(package private) byte[]` `initialSocketData`
`(package private) static int` `MAX_PACKET_SIZE` max bytes streamed in a packet - smaller ones might be filled up to this size.
`(package private) static int` `NETWORK_BUFFER_SIZE`
`(package private) HashMap` `ostreams`
`(package private) Object` `slock`
`(package private) HashMap` `sockets`

Fields inherited from class java.lang.Thread
`MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY`

Constructor Summary
`I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, byte[] initialSocketData, List sockList)`
`I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, byte[] initialSocketData, List sockList, Runnable onTimeout)`
`I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, List sockList)`
`I2PTunnelRunner(Socket s, I2PSocket i2ps, Object slock, byte[] initialI2PData, List sockList, Runnable onTimeout)`

Method Summary
`protected void` `close(OutputStream out, InputStream in, OutputStream i2pout, InputStream i2pin, Socket s, I2PSocket i2ps, Thread t1, Thread t2)`
`void` `errorOccurred()` An error occurred communicating with the peer.
`long` `getLastActivityOn()` When was the last data for this runner sent or received?
`protected InputStream` `getSocketIn()`
`protected OutputStream` `getSocketOut()`
`long` `getStartedOn()` When this runner started up transferring data
`boolean` `isFinished()` have we closed at least one (if not both) of the streams [aka we're done running the streams]?
`void` `run()`

Methods inherited from class net.i2p.util.I2PAppThread
`addOOMEventThreadListener, fireOOM, removeOOMEventThreadListener`

Methods inherited from class net.i2p.util.I2PThread
`addOOMEventListener, finalize, main, removeOOMEventListener`

Methods inherited from class java.lang.Thread

`activeCount, checkAccess, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, toString, yield`

Methods inherited from class java.lang.Object
`clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### MAX_PACKET_SIZE

    static int MAX_PACKET_SIZE

  max bytes streamed in a packet - smaller ones might be filled up to this size. Larger ones are not split (at least not on Sun's impl of BufferedOutputStream), but that is the streaming api's job...

### NETWORK_BUFFER_SIZE

    static final int NETWORK_BUFFER_SIZE

### slock

    final Object slock

### finishLock

    final Object finishLock

### finished

    boolean finished

### ostreams

    HashMap ostreams

### sockets

    HashMap sockets

### initialI2PData

    byte[] initialI2PData

### initialSocketData

    byte[] initialSocketData

Constructor Detail

### I2PTunnelRunner

    public I2PTunnelRunner(Socket s,
                           I2PSocket i2ps,
                           Object slock,
                           byte[] initialI2PData,
                           List sockList)

### I2PTunnelRunner

    public I2PTunnelRunner(Socket s,
                           I2PSocket i2ps,
                           Object slock,
                           byte[] initialI2PData,
                           byte[] initialSocketData,
                           List sockList)

### I2PTunnelRunner

    public I2PTunnelRunner(Socket s,
                           I2PSocket i2ps,
                           Object slock,
                           byte[] initialI2PData,
                           List sockList,
                           Runnable onTimeout)

### I2PTunnelRunner

    public I2PTunnelRunner(Socket s,
                           I2PSocket i2ps,
                           Object slock,
                           byte[] initialI2PData,
                           byte[] initialSocketData,
                           List sockList,
                           Runnable onTimeout)

Method Detail

### isFinished

    public boolean isFinished()

  have we closed at least one (if not both) of the streams [aka we're done running the streams]?

### getLastActivityOn

    public long getLastActivityOn()

  When was the last data for this runner sent or received?

  Returns:
    date (ms since the epoch), or -1 if no data has been transferred yet

### getStartedOn

    public long getStartedOn()

  When this runner started up transferring data

### getSocketIn

    protected InputStream getSocketIn()
                               throws IOException

  Throws:
    `IOException`

### getSocketOut

    protected OutputStream getSocketOut()
                                 throws IOException

  Throws:
    `IOException`

### run

    public void run()

  Specified by:
    `run` in interface `Runnable`
  Overrides:
    `run` in class `I2PThread`

### close

    protected void close(OutputStream out,
                         InputStream in,
                         OutputStream i2pout,
                         InputStream i2pin,
                         Socket s,
                         I2PSocket i2ps,
                         Thread t1,
                         Thread t2)
                  throws InterruptedException,
                         IOException

  Throws:
    `InterruptedException`
    `IOException`

### errorOccurred

    public void errorOccurred()

  Description copied from interface: `I2PSocket.SocketErrorListener`
  An error occurred communicating with the peer.

  Specified by:
    `errorOccurred` in interface `I2PSocket.SocketErrorListener`