## net.i2p.router.tunnel
Class TunnelGateway

    java.lang.Object
      net.i2p.router.tunnel.TunnelGateway

Direct Known Subclasses:
  PumpedTunnelGateway, TunnelGatewayZeroHop

    public class TunnelGateway

extends java.lang.Object

Serve as the gatekeeper for a tunnel, accepting messages, coallescing and/or fragmenting them before wrapping them up for tunnel delivery. The flow here is:

1. add an I2NPMessage (and a target tunnel/router, if necessary)
2. that message is queued up into a TunnelGateway.Pending and offered to the assigned QueuePreprocessor.
3. that QueuePreprocessor may then take off any of the TunnelGateway.Pending messages or instruct the TunnelGateway to offer it the messages again in a short while (in an attempt to coallesce them).
4. when the QueueProcessor accepts a TunnelGateway.Pending, it preprocesses it into fragments, forwarding each preprocessed fragment group through the Sender.
5. the Sender then encrypts the preprocessed data and delivers it to the Receiver.
6. the Receiver now has the encrypted message and may do with it as it pleases (e.g. wrap it as necessary and enqueue it onto the OutNetMessagePool, or if debugging, verify that it can be decrypted properly)

Nested Class Summary
`static class` `TunnelGateway.Pending`
`(package private) class` `TunnelGateway.PendingImpl`
`static interface` `TunnelGateway.QueuePreprocessor`
`static interface` `TunnelGateway.Receiver`
`static interface` `TunnelGateway.Sender`

Field Summary
`protected I2PAppContext` `_context`
`protected net.i2p.router.tunnel.TunnelGateway.DelayedFlush` `_delayedFlush`
`protected int` `_flushFrequency`
`protected long` `_lastFlush`
`protected Log` `_log`
`protected int` `_messagesSent`
`protected TunnelGateway.QueuePreprocessor` `_preprocessor`
`protected java.util.List` `_queue`
`protected TunnelGateway.Receiver` `_receiver`
`protected TunnelGateway.Sender` `_sender`

Constructor Summary
`TunnelGateway(I2PAppContext context, TunnelGateway.QueuePreprocessor preprocessor, TunnelGateway.Sender sender, TunnelGateway.Receiver receiver)`

Method Summary
`void` `add(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)` Add a message to be sent down the tunnel, either sending it now (perhaps coallesced with other pending messages) or after a brief pause (_flushFrequency).
`void` `add(TunnelGatewayMessage msg)` Add a message to be sent down the tunnel, where we are the inbound gateway.
`int` `getMessagesSent()`

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

Field Detail

### _context

    protected I2PAppContext _context

### _log

    protected Log _log

### _queue

    protected java.util.List _queue

### _preprocessor

    protected TunnelGateway.QueuePreprocessor _preprocessor

### _sender

    protected TunnelGateway.Sender _sender

### _receiver

    protected TunnelGateway.Receiver _receiver

### _lastFlush

    protected long _lastFlush

### _flushFrequency

    protected int _flushFrequency

### _delayedFlush

    protected net.i2p.router.tunnel.TunnelGateway.DelayedFlush _delayedFlush

### _messagesSent

    protected int _messagesSent

Constructor Detail

### TunnelGateway

    public TunnelGateway(I2PAppContext context,
                         TunnelGateway.QueuePreprocessor preprocessor,
                         TunnelGateway.Sender sender,
                         TunnelGateway.Receiver receiver)

Parameters:
  `preprocessor` - this pulls Pending messages off a list, builds some full preprocessed messages, and pumps those into the sender
  `sender` - this takes a preprocessed message, encrypts it, and sends it to the receiver
  `receiver` - this receives the encrypted message and forwards it off to the first hop

Method Detail

### add

    public void add(TunnelGatewayMessage msg)

  Add a message to be sent down the tunnel, where we are the inbound gateway.

  Parameters:
    `msg` - message received to be sent through the tunnel

### add

    public void add(I2NPMessage msg,
                    Hash toRouter,
                    TunnelId toTunnel)

  Add a message to be sent down the tunnel, either sending it now (perhaps coallesced with other pending messages) or after a brief pause (_flushFrequency). If it is queued up past its expiration, it is silently dropped

  Parameters:
    `msg` - message to be sent through the tunnel
    `toRouter` - router to send to after the endpoint (or null for endpoint processing)
    `toTunnel` - tunnel to send to after the endpoint (or null for endpoint or router processing)

### getMessagesSent

    public int getMessagesSent()