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

Fields
`(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

Constructors
Constructor and Description
`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

Methods
`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, clone, 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

`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`