Uses of Class
net.i2p.data.Hash

Packages that use Hash
net.i2p.crypto   
net.i2p.data   
net.i2p.data.i2cp   
net.i2p.data.i2np   
net.i2p.router   
net.i2p.router.client   
net.i2p.router.message   
net.i2p.router.networkdb   
net.i2p.router.networkdb.kademlia   
net.i2p.router.peermanager   
net.i2p.router.transport   
net.i2p.router.transport.tcp Implements the transport for communicating with other routers via TCP/IP. 
net.i2p.router.transport.udp   
net.i2p.router.tunnel   
net.i2p.router.tunnel.pool   
 

Uses of Hash in net.i2p.crypto
 

Methods in net.i2p.crypto that return Hash
 Hash SHA256Generator.calculateHash(byte[] source)
          Calculate the SHA-256 has of the source
 Hash SHA256Generator.calculateHash(byte[] source, int start, int len)
           
 Hash HMACGenerator.calculate(SessionKey key, byte[] data)
          Calculate the HMAC of the data with the given key
 Hash DSAEngine.calculateHash(java.io.InputStream in)
           
static Hash DSAEngine.calculateHash(byte[] source, int offset, int len)
           
 

Methods in net.i2p.crypto with parameters of type Hash
 boolean DSAEngine.verifySignature(Signature signature, Hash hash, SigningPublicKey verifyingKey)
           
 Signature DSAEngine.sign(Hash hash, SigningPrivateKey signingKey)
           
 

Uses of Hash in net.i2p.data
 

Fields in net.i2p.data declared as Hash
static Hash Hash.FAKE_HASH
           
 

Methods in net.i2p.data that return Hash
 Hash RoutingKeyGenerator.getRoutingKey(Hash origKey)
          Generate a modified (yet consistent) hash from the origKey by generating the SHA256 of the targetKey with the current modData appended to it, *then* This makes Sybil's job a lot harder, as she needs to essentially take over the whole keyspace.
 Hash RouterInfo.getRoutingKey()
          Get the routing key for the structure using the current modifier in the RoutingKeyGenerator.
 Hash RouterIdentity.calculateHash()
           
 Hash RouterIdentity.getHash()
           
 Hash LeaseSet.getRoutingKey()
          Get the routing key for the structure using the current modifier in the RoutingKeyGenerator.
 Hash Lease.getGateway()
          Retrieve the router at which the destination can be contacted
 Hash Destination.calculateHash()
           
 Hash DataStructureImpl.calculateHash()
           
 Hash DataStructure.calculateHash()
          Calculate the SHA256 value of this object (useful for a few scenarios)
 

Methods in net.i2p.data with parameters of type Hash
 Hash RoutingKeyGenerator.getRoutingKey(Hash origKey)
          Generate a modified (yet consistent) hash from the origKey by generating the SHA256 of the targetKey with the current modData appended to it, *then* This makes Sybil's job a lot harder, as she needs to essentially take over the whole keyspace.
 void RouterInfo.setRoutingKey(Hash key)
           
 void LeaseSet.setRoutingKey(Hash key)
           
 void Lease.setGateway(Hash ident)
          Configure the router at which the destination can be contacted
 byte[] Hash.cachedXor(Hash key)
          Calculate the xor with the current object and the specified hash, caching values where possible.
 

Uses of Hash in net.i2p.data.i2cp
 

Methods in net.i2p.data.i2cp that return Hash
 Hash RequestLeaseSetMessage.getRouter(int endpoint)
           
 

Methods in net.i2p.data.i2cp with parameters of type Hash
 void RequestLeaseSetMessage.addEndpoint(Hash router, TunnelId tunnel)
           
 

Uses of Hash in net.i2p.data.i2np
 

Methods in net.i2p.data.i2np that return Hash
 Hash TunnelVerificationStructure.getMessageHash()
           
 Hash TunnelCreateMessage.getNextRouter()
           
 Hash TunnelCreateMessage.getReplyGateway()
           
 Hash DeliveryInstructions.getDestination()
           
 Hash DeliveryInstructions.getRouter()
           
 Hash DatabaseStoreMessage.getKey()
          Defines the key in the network database being stored
 Hash DatabaseStoreMessage.getReplyGateway()
           
 Hash DatabaseSearchReplyMessage.getSearchKey()
          Defines the key being searched for
 Hash DatabaseSearchReplyMessage.getReply(int index)
           
 Hash DatabaseSearchReplyMessage.getFromHash()
           
 Hash DatabaseLookupMessage.getSearchKey()
          Defines the key being searched for
 Hash DatabaseLookupMessage.getFrom()
          Contains the router who requested this lookup
 Hash BuildRequestRecord.readNextIdentity()
          Read the next hop from the record.
 

Methods in net.i2p.data.i2np with parameters of type Hash
 void TunnelVerificationStructure.setMessageHash(Hash hash)
           
 void TunnelCreateMessage.setNextRouter(Hash routerIdentityHash)
           
 void TunnelCreateMessage.setReplyGateway(Hash peer)
           
 void DeliveryInstructions.setDestination(Hash dest)
           
 void DeliveryInstructions.setRouter(Hash router)
           
 void DatabaseStoreMessage.setKey(Hash key)
           
 void DatabaseStoreMessage.setReplyGateway(Hash peer)
           
 void DatabaseSearchReplyMessage.setSearchKey(Hash key)
           
 void DatabaseSearchReplyMessage.addReply(Hash peer)
           
 void DatabaseSearchReplyMessage.setFromHash(Hash from)
           
 void DatabaseLookupMessage.setSearchKey(Hash key)
           
 void DatabaseLookupMessage.setFrom(Hash from)
           
 boolean BuildRequestRecord.readOurIdentityMatches(Hash ourIdentity)
          true if the identity they expect us to be is who we are
 void BuildRequestRecord.encryptRecord(I2PAppContext ctx, PublicKey toKey, Hash toPeer, byte[] out, int outOffset)
          Encrypt the record to the specified peer.
 boolean BuildRequestRecord.decryptRecord(I2PAppContext ctx, PrivateKey ourKey, Hash ourIdent, ByteArray encryptedRecord)
          Decrypt the data from the specified record, writing the decrypted record into this instance's buffer (but not overwriting the array contained within the old buffer)
 void BuildRequestRecord.createRecord(I2PAppContext ctx, long receiveTunnelId, Hash peer, long nextTunnelId, Hash nextHop, long nextMsgId, SessionKey layerKey, SessionKey ivKey, SessionKey replyKey, byte[] iv, boolean isInGateway, boolean isOutEndpoint)
          Populate this instance with data.
 

Constructors in net.i2p.data.i2np with parameters of type Hash
TunnelVerificationStructure(Hash messageHash, Signature authSig)
           
 

Uses of Hash in net.i2p.router
 

Methods in net.i2p.router that return Hash
 Hash DummyPeerManagerFacade.selectRandomByCapability(char capability)
           
 Hash TunnelPoolSettings.getDestination()
          what destination is this a tunnel for (or null if none)
 Hash TunnelInfo.getPeer(int hop)
          retrieve the peer at the given hop.
 Hash TunnelInfo.getDestination()
          if this is a client tunnel, what destination is it for?
 Hash RouterContext.routerHash()
          convenience method for querying the router's ident
 Hash PeerManagerFacade.selectRandomByCapability(char capability)
           
 Hash MessageReceptionInfo.getFromPeer()
          Hash of the RouterIdentity of the peer that sent the message
 Hash ClientMessage.getDestinationHash()
          Retrieve the destination to which this message is directed.
 

Methods in net.i2p.router with parameters of type Hash
 TunnelInfo DummyTunnelManagerFacade.selectInboundTunnel(Hash destination)
           
 TunnelInfo DummyTunnelManagerFacade.selectOutboundTunnel(Hash destination)
           
 boolean DummyTunnelManagerFacade.isInUse(Hash peer)
           
 TunnelPoolSettings DummyTunnelManagerFacade.getInboundSettings(Hash client)
           
 TunnelPoolSettings DummyTunnelManagerFacade.getOutboundSettings(Hash client)
           
 void DummyTunnelManagerFacade.setInboundSettings(Hash client, TunnelPoolSettings settings)
           
 void DummyTunnelManagerFacade.setOutboundSettings(Hash client, TunnelPoolSettings settings)
           
 void DummyPeerManagerFacade.setCapabilities(Hash peer, java.lang.String caps)
           
 void DummyPeerManagerFacade.removeCapabilities(Hash peer)
           
 void DummyNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)
           
 LeaseSet DummyNetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)
           
 void DummyNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)
           
 RouterInfo DummyNetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)
           
 LeaseSet DummyNetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)
           
 RouterInfo DummyNetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)
           
 void DummyNetworkDatabaseFacade.fail(Hash dbEntry)
           
 java.util.Set DummyNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, java.util.Set peersToIgnore)
           
 boolean DummyClientManagerFacade.isLocal(Hash destHash)
           
 void DummyClientManagerFacade.requestLeaseSet(Hash dest, LeaseSet set)
           
 void TunnelPoolSettings.setDestination(Hash dest)
           
 TunnelInfo TunnelManagerFacade.selectInboundTunnel(Hash destination)
          pick an inbound tunnel bound to the given destination
 TunnelInfo TunnelManagerFacade.selectOutboundTunnel(Hash destination)
          pick an outbound tunnel bound to the given destination
 boolean TunnelManagerFacade.isInUse(Hash peer)
          True if the peer currently part of a tunnel
 TunnelPoolSettings TunnelManagerFacade.getInboundSettings(Hash client)
           
 TunnelPoolSettings TunnelManagerFacade.getOutboundSettings(Hash client)
           
 void TunnelManagerFacade.setInboundSettings(Hash client, TunnelPoolSettings settings)
           
 void TunnelManagerFacade.setOutboundSettings(Hash client, TunnelPoolSettings settings)
           
 boolean Shitlist.shitlistRouter(Hash peer)
           
 boolean Shitlist.shitlistRouter(Hash peer, java.lang.String reason)
           
 boolean Shitlist.shitlistRouter(Hash peer, java.lang.String reason, java.lang.String transport)
           
 void Shitlist.unshitlistRouter(Hash peer)
           
 void Shitlist.unshitlistRouter(Hash peer, java.lang.String transport)
           
 boolean Shitlist.isShitlisted(Hash peer)
           
 boolean Shitlist.isShitlisted(Hash peer, java.lang.String transport)
           
 boolean RouterThrottleImpl.acceptNetDbLookupRequest(Hash key)
           
 boolean RouterThrottle.acceptNetDbLookupRequest(Hash key)
          Should we accept the netDb lookup message, replying either with the value or some closer peers, or should we simply drop it due to overload?
 boolean RouterDoSThrottle.acceptNetDbLookupRequest(Hash key)
           
 void ProfileManager.messageSent(Hash peer, java.lang.String transport, long msToSend, long bytesSent)
          Note that it took msToSend to send a message of size bytesSent to the peer over the transport.
 void ProfileManager.messageFailed(Hash peer, java.lang.String transport)
          Note that the router failed to send a message to the peer over the transport specified
 void ProfileManager.messageFailed(Hash peer)
          Note that the router failed to send a message to the peer over any transport
 void ProfileManager.commErrorOccurred(Hash peer)
          Note that there was some sort of communication error talking with the peer
 void ProfileManager.tunnelJoined(Hash peer, long responseTimeMs)
          Note that the router agreed to participate in a tunnel
 void ProfileManager.tunnelRejected(Hash peer, long responseTimeMs, int severity)
          Note that a router explicitly rejected joining a tunnel
 void ProfileManager.tunnelTestSucceeded(Hash peer, long responseTimeMs)
          Note that a tunnel that the router is participating in was successfully tested with the given round trip latency
 void ProfileManager.tunnelDataPushed(Hash peer, long rtt, int size)
          Note that we were able to push some data through a tunnel that the peer is participating in (detected after rtt).
 void ProfileManager.tunnelDataPushed1m(Hash peer, int size)
          Note that the peer is participating in a tunnel that pushed the given amount of data over the last minute.
 void ProfileManager.tunnelLifetimePushed(Hash peer, long lifetime, long size)
          Note that we were able to push the given amount of data through a tunnel that the peer is participating in
 void ProfileManager.tunnelFailed(Hash peer)
          Note that the peer participated in a tunnel that failed.
 void ProfileManager.dbLookupSuccessful(Hash peer, long responseTimeMs)
          Note that the peer was able to return the valid data for a db lookup
 void ProfileManager.dbLookupFailed(Hash peer)
          Note that the peer was unable to reply to a db lookup - either with data or with a lookupReply redirecting the user elsewhere
 void ProfileManager.dbLookupReply(Hash peer, int newPeers, int oldPeers, int invalid, int duplicate, long responseTimeMs)
          Note that the peer replied to a db lookup with a redirect to other routers, where the list of redirected users included newPeers routers that the local router didn't know about, oldPeers routers that the local router already knew about, the given invalid routers that were invalid in some way, and the duplicate number of routers that we explicitly asked them not to send us, but they did anyway
 void ProfileManager.dbLookupReceived(Hash peer)
          Note that the local router received a db lookup from the given peer
 void ProfileManager.dbStoreReceived(Hash peer, boolean wasNewKey)
          Note that the local router received an unprompted db store from the given peer
 void ProfileManager.dbStoreSent(Hash peer, long responseTimeMs)
          Note that we've confirmed a successful send of db data to the peer (though we haven't necessarily requested it again from them, so they /might/ be lying)
 void ProfileManager.dbStoreFailed(Hash peer)
          Note that we were unable to confirm a successful send of db data to the peer, at least not within our timeout period
 void ProfileManager.heardAbout(Hash peer)
          Note that the local router received a reference to the given peer, either through an explicit dbStore or in a dbLookupReply
 void ProfileManager.messageReceived(Hash peer, java.lang.String style, long msToReceive, int bytesRead)
          Note that the router received a message from the given peer on the specified transport.
 void PeerManagerFacade.setCapabilities(Hash peer, java.lang.String caps)
           
 void PeerManagerFacade.removeCapabilities(Hash peer)
           
abstract  java.util.Set NetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, java.util.Set peersToIgnore)
          Return the RouterInfo structures for the routers closest to the given key.
abstract  void NetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)
           
abstract  LeaseSet NetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)
           
abstract  void NetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)
           
abstract  RouterInfo NetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)
           
abstract  LeaseSet NetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)
          return the leaseSet if another leaseSet already existed at that key
abstract  RouterInfo NetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)
          return the routerInfo if another router already existed at that key
abstract  void NetworkDatabaseFacade.fail(Hash dbEntry)
           
 void MessageReceptionInfo.setFromPeer(Hash routerIdentityHash)
           
 void MessageHistory.requestTunnelCreate(TunnelId createTunnel, TunnelId outTunnel, Hash peerRequested, Hash nextPeer, TunnelId replyTunnel, Hash replyThrough)
          We are requesting that the peerRequested create the tunnel specified with the given nextPeer, and we are sending that request to them through outTunnel with a request that the reply is sent back to us through replyTunnel on the given replyThrough router.
 void MessageHistory.receiveTunnelCreate(TunnelId createTunnel, Hash nextPeer, java.util.Date expire, boolean ok, Hash sourceRoutePeer)
          The local router has received a request to join the createTunnel with the next hop being nextPeer, and we should send our decision to join it through sourceRoutePeer
 void MessageHistory.tunnelDispatched(long messageId, long tunnelId, long toTunnel, Hash toPeer, java.lang.String type)
           
 void MessageHistory.tunnelRejected(Hash peer, TunnelId tunnel, Hash replyThrough, java.lang.String reason)
          The peer did not accept the tunnel join for the given reason
 void MessageHistory.tunnelParticipantRejected(Hash peer, java.lang.String msg)
           
 void MessageHistory.tunnelRequestTimedOut(Hash peer, TunnelId tunnel)
          The peer did not accept the tunnel join for the given reason (this may be because of a timeout or an explicit refusal).
 void MessageHistory.droppedTunnelMessage(TunnelId id, long msgId, java.util.Date expiration, Hash from)
          We don't know about the given tunnel, so we are dropping a message sent to us by the given router
 void MessageHistory.droppedOtherMessage(I2NPMessage message, Hash from)
          We received another message we weren't waiting for and don't know how to handle
 void MessageHistory.droppedInboundMessage(long messageId, Hash from, java.lang.String info)
           
 void MessageHistory.shitlist(Hash peer, java.lang.String reason)
          We shitlisted the peer
 void MessageHistory.unshitlist(Hash peer)
          We unshitlisted the peer
 void MessageHistory.sendMessage(java.lang.String messageType, long messageId, long expiration, Hash peer, boolean sentOk, java.lang.String info)
          We just sent a message to the peer
 void MessageHistory.receiveMessage(java.lang.String messageType, long messageId, long expiration, Hash from, boolean isValid)
          We just received a message from the peer
 LeaseSetKeys KeyManager.getKeys(Hash dest)
           
 int InNetMessagePool.add(I2NPMessage messageBody, RouterIdentity fromRouter, Hash fromRouterHash)
          Add a new message to the pool, returning the number of messages in the pool so that the comm system can throttle inbound messages.
 Job HandlerJobBuilder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
          Create a new job to handle the received message.
 void ClientMessage.setDestinationHash(Hash dest)
           
abstract  void ClientManagerFacade.requestLeaseSet(Hash dest, LeaseSet set)
           
abstract  boolean ClientManagerFacade.isLocal(Hash destHash)
          Determine if the destination hash specified is managed locally.
 boolean ClientManagerFacade.shouldPublishLeaseSet(Hash destinationHash)
          Does the client specified want their leaseSet published?
 

Uses of Hash in net.i2p.router.client
 

Methods in net.i2p.router.client that return Hash
 Hash ClientConnectionRunner.getDestHash()
           
 

Methods in net.i2p.router.client with parameters of type Hash
 void ClientManagerFacadeImpl.requestLeaseSet(Hash dest, LeaseSet set)
           
 boolean ClientManagerFacadeImpl.isLocal(Hash destHash)
          Determine if the destination specified is managed locally.
 boolean ClientManagerFacadeImpl.shouldPublishLeaseSet(Hash destinationHash)
           
 void ClientManager.requestLeaseSet(Hash dest, LeaseSet ls)
           
 boolean ClientManager.isLocal(Hash destHash)
           
 boolean ClientManager.shouldPublishLeaseSet(Hash destHash)
           
 

Uses of Hash in net.i2p.router.message
 

Methods in net.i2p.router.message with parameters of type Hash
 boolean OutboundClientMessageStatus.alreadySent(Hash gateway, TunnelId tunnelId)
          have we already sent the message down this tunnel?
 void OutboundClientMessageStatus.sent(Hash gateway, TunnelId tunnelId)
           
(package private) static GarlicMessage OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, Payload data, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, java.util.Set wrappedTags, boolean requireAck, LeaseSet bundledReplyLeaseSet)
          Build a garlic message that will be delivered to the router on which the target is located.
(package private) static GarlicMessage OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, PayloadGarlicConfig dataClove, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, java.util.Set wrappedTags, boolean requireAck, LeaseSet bundledReplyLeaseSet)
          Allow the app to specify the data clove directly, which enables OutboundClientMessage to resend the same payload (including expiration and unique id) in different garlics (down different tunnels)
 Job GarlicMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 

Constructors in net.i2p.router.message with parameters of type Hash
SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, int timeoutMs, int priority)
           
SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, ReplyJob onSuccess, Job onFail, MessageSelector selector, int timeoutMs, int priority)
           
SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, Job onSend, ReplyJob onSuccess, Job onFail, MessageSelector selector, int timeoutMs, int priority)
           
HandleGarlicMessageJob(RouterContext context, GarlicMessage msg, RouterIdentity from, Hash fromHash)
           
GarlicMessageReceiver(RouterContext context, GarlicMessageReceiver.CloveReceiver receiver, Hash clientDestination)
           
BuildTestMessageJob(RouterContext ctx, RouterInfo target, Hash replyTo, Job onSendJob, Job onSendFailedJob, long timeoutMs, int priority)
           
 

Uses of Hash in net.i2p.router.networkdb
 

Methods in net.i2p.router.networkdb with parameters of type Hash
 Job DatabaseStoreMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 Job DatabaseLookupMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 

Constructors in net.i2p.router.networkdb with parameters of type Hash
HandleDatabaseStoreMessageJob(RouterContext ctx, DatabaseStoreMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
HandleDatabaseLookupMessageJob(RouterContext ctx, DatabaseLookupMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 

Uses of Hash in net.i2p.router.networkdb.kademlia
 

Methods in net.i2p.router.networkdb.kademlia that return Hash
(package private)  Hash FloodSearchJob.getKey()
           
 Hash StoreState.getTarget()
           
 Hash SearchState.getTarget()
           
 Hash KBucketImpl.getLocal()
           
 Hash KBucketImpl.generateRandomKey()
          Generate a random key to go within this bucket
 Hash KBucketImpl.getRangeBeginKey()
           
 Hash KBucketImpl.getRangeEndKey()
           
 Hash KBucket.generateRandomKey()
          Generate a random key that would go inside this bucket
 Hash KBucket.getLocal()
           
(package private)  Hash FloodOnlySearchJob.getKey()
           
 

Methods in net.i2p.router.networkdb.kademlia with parameters of type Hash
 DataStructure TransientDataStore.get(Hash key)
           
 boolean TransientDataStore.isKnown(Hash key)
           
 void TransientDataStore.put(Hash key, DataStructure data)
           
 DataStructure TransientDataStore.remove(Hash key)
           
 void StoreState.addPending(Hash peer)
           
 void StoreState.addSkipped(Hash peer)
          we aren't even going to try to contact this peer
 long StoreState.confirmed(Hash peer)
           
 long StoreState.confirmedExploratory(Hash peer)
           
 void StoreState.replyTimeout(Hash peer)
           
 void SelectionCollector.add(Hash entry)
           
 boolean SearchState.wasAttempted(Hash peer)
           
 void SearchState.addPending(Hash peer)
           
 void SearchState.removePending(Hash peer)
          we didn't actually want to add this peer as part of the pending list...
 long SearchState.dataFound(Hash peer)
          how long did it take to get the reply, or -1 if we don't know
 long SearchState.replyFound(Hash peer)
          how long did it take to get the reply, or -1 if we dont know
 void SearchState.replyTimeout(Hash peer)
           
protected  int SearchJob.getPerPeerTimeoutMs(Hash peer)
           
protected  DatabaseLookupMessage SearchJob.buildMessage(TunnelId replyTunnelId, Hash replyGateway, long expiration)
          Build the database search message
(package private)  void SearchJob.replyFound(DatabaseSearchReplyMessage message, Hash peer)
           
(package private)  boolean SearchJob.wasAttempted(Hash peer)
           
(package private)  boolean SearchJob.add(Hash peer)
           
 DataStructure PersistentDataStore.remove(Hash key)
           
 void PersistentDataStore.put(Hash key, DataStructure data)
           
 java.util.List PeerSelector.selectMostReliablePeers(Hash key, int numClosest, java.util.Set alreadyChecked, KBucketSet kbuckets)
          Search through the kbucket set to find the most reliable peers close to the given key, skipping all of the ones already checked
 java.util.List PeerSelector.selectNearestExplicit(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)
          Ignore KBucket ordering and do the XOR explicitly per key.
 java.util.List PeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)
          Ignore KBucket ordering and do the XOR explicitly per key.
protected  java.math.BigInteger PeerSelector.getDistance(Hash targetKey, Hash routerInQuestion)
           
 java.util.List PeerSelector.selectNearest(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)
          Generic KBucket filtering to find the hashes close to a key, regardless of other considerations.
(package private)  void KademliaNetworkDatabaseFacade.searchComplete(Hash key)
          The search for the given key is no longer active
 java.lang.Long KademliaNetworkDatabaseFacade.getLastSent(Hash key)
           
 void KademliaNetworkDatabaseFacade.noteKeySent(Hash key)
           
 java.util.Set KademliaNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, java.util.Set peersToIgnore)
          Get the routers closest to that key in response to a remote lookup
 void KademliaNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)
           
 LeaseSet KademliaNetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)
           
 void KademliaNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)
           
 RouterInfo KademliaNetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)
           
(package private)  void KademliaNetworkDatabaseFacade.stopPublishing(Hash target)
           
(package private)  java.lang.String KademliaNetworkDatabaseFacade.validate(Hash key, LeaseSet leaseSet)
          Determine whether this leaseSet will be accepted as valid and current given what we know now.
 LeaseSet KademliaNetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)
          Store the leaseSet
(package private)  java.lang.String KademliaNetworkDatabaseFacade.validate(Hash key, RouterInfo routerInfo)
          Determine whether this routerInfo will be accepted as valid and current given what we know now.
 RouterInfo KademliaNetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)
          store the routerInfo
 void KademliaNetworkDatabaseFacade.fail(Hash dbEntry)
           
protected  void KademliaNetworkDatabaseFacade.lookupBeforeDropping(Hash peer, RouterInfo info)
           
protected  void KademliaNetworkDatabaseFacade.dropAfterLookupFailed(Hash peer, RouterInfo info)
           
(package private)  SearchJob KademliaNetworkDatabaseFacade.search(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs, boolean isLease)
          Begin a kademlia style search for the key specified, which can take up to timeoutMs and will fire the appropriate jobs on success or timeout (or if the kademlia search completes without any match)
 int KademliaNetworkDatabaseFacade.getPeerTimeout(Hash peer)
           
 void KademliaNetworkDatabaseFacade.sendStore(Hash key, DataStructure ds, Job onSuccess, Job onFailure, long sendTimeout, java.util.Set toIgnore)
           
 boolean KBucketSet.add(Hash peer)
          Return true if the peer is new to the bucket it goes in, or false if it was already in it
 boolean KBucketSet.remove(Hash entry)
           
 int KBucketSet.pickBucket(Hash key)
           
 boolean KBucketImpl.shouldContain(Hash key)
           
 int KBucketImpl.add(Hash peer)
           
 boolean KBucketImpl.remove(Hash peer)
           
 boolean KBucket.shouldContain(Hash key)
          whether or not the key qualifies as part of this bucket
 int KBucket.add(Hash key)
          Add the peer to the bucket
 boolean KBucket.remove(Hash key)
          Remove the key from the bucket
 java.util.List FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)
          Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
 void FloodfillNetworkDatabaseFacade.sendStore(Hash key, DataStructure ds, Job onSuccess, Job onFailure, long sendTimeout, java.util.Set toIgnore)
           
(package private)  SearchJob FloodfillNetworkDatabaseFacade.search(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs, boolean isLease)
          Begin a kademlia style search for the key specified, which can take up to timeoutMs and will fire the appropriate jobs on success or timeout (or if the kademlia search completes without any match)
(package private)  void FloodfillNetworkDatabaseFacade.searchFull(Hash key, java.util.List onFind, java.util.List onFailed, long timeoutMs, boolean isLease)
          Ok, the initial set of searches to the floodfill peers timed out, lets fall back on the wider kademlia-style searches
(package private)  void FloodfillNetworkDatabaseFacade.complete(Hash key)
           
protected  void FloodfillNetworkDatabaseFacade.lookupBeforeDropping(Hash peer, RouterInfo info)
           
 Job FloodfillDatabaseStoreMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 Job FloodfillDatabaseLookupMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 boolean DataStore.isKnown(Hash key)
           
 DataStructure DataStore.get(Hash key)
           
 void DataStore.put(Hash key, DataStructure data)
           
 DataStructure DataStore.remove(Hash key)
           
 

Constructors in net.i2p.router.networkdb.kademlia with parameters of type Hash
ReplyNotVerifiedJob(RouterContext enclosingContext, SearchReplyJob srj, Hash key)
           
ReplyVerifiedJob(RouterContext enclosingContext, SearchReplyJob srj, Hash key)
           
SearchReplyJob(RouterContext enclosingContext, SearchJob job, DatabaseSearchReplyMessage message, Hash peer, long duration)
           
FloodSearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)
           
XORComparator(Hash target)
           
StoreState(RouterContext ctx, Hash key, DataStructure data)
           
StoreState(RouterContext ctx, Hash key, DataStructure data, java.util.Set toSkip)
           
SearchState(RouterContext context, Hash key)
           
StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs)
          Create a new search for the routingKey specified
StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs, java.util.Set toSkip)
           
SearchJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, Job onSuccess, Job onFailure, long timeoutMs, boolean keepStats, boolean isLease)
          Create a new search for the routingKey specified
RepublishLeaseSetJob(RouterContext ctx, KademliaNetworkDatabaseFacade facade, Hash destHash)
           
KBucketSet(I2PAppContext context, Hash us)
           
KBucketImpl(I2PAppContext context, Hash local)
           
HandleFloodfillDatabaseStoreMessageJob(RouterContext ctx, DatabaseStoreMessage receivedMessage, RouterIdentity from, Hash fromHash, FloodfillNetworkDatabaseFacade facade)
           
HandleFloodfillDatabaseLookupMessageJob(RouterContext ctx, DatabaseLookupMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
FloodfillVerifyStoreJob(RouterContext ctx, Hash key, FloodfillNetworkDatabaseFacade facade)
           
FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs)
          Create a new search for the routingKey specified
FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs, java.util.Set toSkip)
           
FloodOnlySearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)
           
ExploreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key)
          Create a new search for the routingKey specified
 

Uses of Hash in net.i2p.router.peermanager
 

Methods in net.i2p.router.peermanager that return Hash
(package private)  Hash ProfileOrganizer.getUs()
           
 Hash PeerProfile.getPeer()
          what peer is being profiled
 Hash PeerManagerFacadeImpl.selectRandomByCapability(char capability)
           
 Hash PeerManager.selectRandomByCapability(char capability)
           
 

Methods in net.i2p.router.peermanager with parameters of type Hash
 void ProfilePersistenceHelper.setUs(Hash routerIdentHash)
           
 void ProfileOrganizer.setUs(Hash us)
           
 PeerProfile ProfileOrganizer.getProfile(Hash peer)
          Retrieve the profile for the given peer, if one exists (else null)
 boolean ProfileOrganizer.isFast(Hash peer)
           
 boolean ProfileOrganizer.isHighCapacity(Hash peer)
           
 boolean ProfileOrganizer.isWellIntegrated(Hash peer)
           
 boolean ProfileOrganizer.isFailing(Hash peer)
           
 boolean ProfileOrganizer.peerSendsBadReplies(Hash peer)
          Does the given peer send us bad replies - either invalid store messages (expired, corrupt, etc) or unreachable replies (pointing towards routers that don't exist).
 void ProfileOrganizer.exportProfile(Hash profile, java.io.OutputStream out)
           
 boolean ProfileOrganizer.isSelectable(Hash peer)
           
 void ProfileManagerImpl.messageSent(Hash peer, java.lang.String transport, long msToSend, long bytesSent)
          Note that it took msToSend to send a message of size bytesSent to the peer over the transport.
 void ProfileManagerImpl.messageFailed(Hash peer, java.lang.String transport)
          Note that the router failed to send a message to the peer over the transport specified
 void ProfileManagerImpl.messageFailed(Hash peer)
          Note that the router failed to send a message to the peer over any transport
 void ProfileManagerImpl.commErrorOccurred(Hash peer)
          Note that there was some sort of communication error talking with the peer
 void ProfileManagerImpl.tunnelJoined(Hash peer, long responseTimeMs)
          Note that the router agreed to participate in a tunnel
 void ProfileManagerImpl.tunnelRejected(Hash peer, long responseTimeMs, int severity)
          Note that a router explicitly rejected joining a tunnel.
 void ProfileManagerImpl.tunnelTestSucceeded(Hash peer, long responseTimeMs)
          Note that a tunnel that the router is participating in was successfully tested with the given round trip latency
 void ProfileManagerImpl.tunnelDataPushed(Hash peer, long rtt, int size)
           
 void ProfileManagerImpl.tunnelDataPushed1m(Hash peer, int size)
           
 void ProfileManagerImpl.tunnelLifetimePushed(Hash peer, long lifetime, long size)
           
 void ProfileManagerImpl.tunnelFailed(Hash peer)
          Note that the peer participated in a tunnel that failed.
 void ProfileManagerImpl.dbLookupSuccessful(Hash peer, long responseTimeMs)
          Note that the peer was able to return the valid data for a db lookup
 void ProfileManagerImpl.dbLookupFailed(Hash peer)
          Note that the peer was unable to reply to a db lookup - either with data or with a lookupReply redirecting the user elsewhere
 void ProfileManagerImpl.dbLookupReply(Hash peer, int newPeers, int oldPeers, int invalid, int duplicate, long responseTimeMs)
          Note that the peer replied to a db lookup with a redirect to other routers, where the list of redirected users included newPeers routers that the local router didn't know about, oldPeers routers that the local router already knew about, the given invalid routers that were invalid in some way, and the duplicate number of routers that we explicitly asked them not to send us, but they did anyway
 void ProfileManagerImpl.dbLookupReceived(Hash peer)
          Note that the local router received a db lookup from the given peer
 void ProfileManagerImpl.dbStoreReceived(Hash peer, boolean wasNewKey)
          Note that the local router received an unprompted db store from the given peer
 void ProfileManagerImpl.dbStoreSent(Hash peer, long responseTimeMs)
          Note that we've confirmed a successful send of db data to the peer (though we haven't necessarily requested it again from them, so they /might/ be lying)
 void ProfileManagerImpl.dbStoreFailed(Hash peer)
          Note that we were unable to confirm a successful send of db data to the peer, at least not within our timeout period
 void ProfileManagerImpl.heardAbout(Hash peer)
          Note that the local router received a reference to the given peer, either through an explicit dbStore or in a dbLookupReply
 void ProfileManagerImpl.messageReceived(Hash peer, java.lang.String style, long msToReceive, int bytesRead)
          Note that the router received a message from the given peer on the specified transport.
(package private)  void PersistProfilesJob.persist(Hash peer)
           
 void PeerProfile.setPeer(Hash peer)
           
 void PeerManagerFacadeImpl.setCapabilities(Hash peer, java.lang.String caps)
           
 void PeerManagerFacadeImpl.removeCapabilities(Hash peer)
           
(package private)  void PeerManager.storeProfile(Hash peer)
           
 void PeerManager.setCapabilities(Hash peer, java.lang.String caps)
           
 void PeerManager.removeCapabilities(Hash peer)
           
 

Constructors in net.i2p.router.peermanager with parameters of type Hash
PeerProfile(RouterContext context, Hash peer)
           
PeerProfile(RouterContext context, Hash peer, boolean expand)
           
 

Uses of Hash in net.i2p.router.transport
 

Methods in net.i2p.router.transport with parameters of type Hash
 void VMCommSystem.receive(byte[] message, Hash fromPeer)
          We send messages between comms as bytes so that we strip any router-local info.
 void TransportManager.messageReceived(I2NPMessage message, RouterIdentity fromRouter, Hash fromRouterHash)
           
 void TransportImpl.messageReceived(I2NPMessage inMsg, RouterIdentity remoteIdent, Hash remoteIdentHash, long msToReceive, int bytesReceived)
          Message received from the I2NPMessageReader - send it to the listener
 boolean TransportImpl.isUnreachable(Hash peer)
           
 void TransportImpl.markUnreachable(Hash peer)
          called when we can't reach a peer
 void TransportImpl.markReachable(Hash peer)
          called when we establish a peer connection (outbound or inbound)
 void TransportEventListener.messageReceived(I2NPMessage message, RouterIdentity fromRouter, Hash fromRouterHash)
           
 boolean Transport.isUnreachable(Hash peer)
           
 

Uses of Hash in net.i2p.router.transport.tcp
 

Methods in net.i2p.router.transport.tcp that return Hash
 Hash TCPConnection.getAttemptedPeer()
          Who we initially were trying to contact
 

Methods in net.i2p.router.transport.tcp with parameters of type Hash
 void TCPConnection.setAttemptedPeer(Hash peer)
          Who we initially were trying to contact
 ByteArray ConnectionTagManager.getTag(Hash peer)
          Retrieve the associated tag (but do not consume it)
 SessionKey ConnectionTagManager.getKey(Hash peer)
           
 void ConnectionTagManager.replaceTag(Hash peer, ByteArray newTag, SessionKey key)
          Update the tag associated with a peer, dropping the old one
 

Uses of Hash in net.i2p.router.transport.udp
 

Methods in net.i2p.router.transport.udp that return Hash
 Hash PeerState.getRemotePeer()
          The peer are we talking to.
 Hash InboundMessageState.getFrom()
           
 

Methods in net.i2p.router.transport.udp with parameters of type Hash
(package private)  void UDPTransport.externalAddressReceived(Hash from, byte[] ourIP, int ourPort)
          Someone we tried to contact gave us what they think our IP address is.
 PeerState UDPTransport.getPeerState(Hash remotePeer)
          get the state for the peer with the given ident, or null if no state exists
 void UDPTransport.messageReceived(I2NPMessage inMsg, RouterIdentity remoteIdent, Hash remoteIdentHash, long msToReceive, int bytesReceived)
           
(package private)  void UDPTransport.dropPeer(Hash peer, boolean shouldShitlist, java.lang.String why)
           
 void TimedWeightedPriorityMessageQueue.choke(Hash peer)
           
 void TimedWeightedPriorityMessageQueue.unchoke(Hash peer)
           
 boolean TimedWeightedPriorityMessageQueue.isChoked(Hash peer)
           
 void PeerState.setRemotePeer(Hash peer)
          The peer are we talking to.
 int OutboundMessageFragments.acked(long messageId, Hash ackedBy)
          We received an ACK of the given messageId from the given peer, so if it is still unacked, mark it as complete.
 void OutboundMessageFragments.acked(ACKBitfield bitfield, Hash ackedBy)
           
 void OutboundMessageFragments.ActiveThrottle.choke(Hash peer)
           
 void OutboundMessageFragments.ActiveThrottle.unchoke(Hash peer)
           
 boolean OutboundMessageFragments.ActiveThrottle.isChoked(Hash peer)
           
 

Constructors in net.i2p.router.transport.udp with parameters of type Hash
InboundMessageState(RouterContext ctx, long messageId, Hash from)
           
 

Uses of Hash in net.i2p.router.tunnel
 

Fields in net.i2p.router.tunnel declared as Hash
protected  Hash TunnelGateway.Pending._toRouter
           
 

Methods in net.i2p.router.tunnel that return Hash
 Hash TunnelGateway.Pending.getToRouter()
          may be null
 Hash TunnelCreatorConfig.getPeer(int hop)
          retrieve the peer at the given hop.
 Hash TunnelCreatorConfig.getDestination()
          if this is a client tunnel, what destination is it for?
 Hash InboundEndpointProcessor.getDestination()
           
 Hash HopConfig.getReceiveFrom()
          what is the previous peer in the tunnel (if any)?
 Hash HopConfig.getSendTo()
          what is the next peer in the tunnel (if any)?
 Hash FragmentedMessage.getTargetRouter()
           
 

Methods in net.i2p.router.tunnel with parameters of type Hash
 void TunnelParticipant.dispatch(TunnelDataMessage msg, Hash recvFrom)
           
 void TunnelGatewayZeroHop.add(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)
          Add a message to be sent down the tunnel (immediately forwarding it to the InboundMessageDistributor or OutboundMessageDistributor, as necessary).
 void TunnelGateway.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 TunnelDispatcher.dispatch(TunnelDataMessage msg, Hash recvFrom)
          We are participating in a tunnel (perhaps we're even the endpoint), so take the message and do what it says.
 void TunnelDispatcher.dispatchOutbound(I2NPMessage msg, TunnelId outboundTunnel, Hash targetPeer)
          We are the outbound tunnel gateway (we created it), so wrap up this message with instructions to be forwarded to the targetPeer when it reaches the endpoint.
 void TunnelDispatcher.dispatchOutbound(I2NPMessage msg, TunnelId outboundTunnel, TunnelId targetTunnel, Hash targetPeer)
          We are the outbound tunnel gateway (we created it), so wrap up this message with instructions to be forwarded to the targetTunnel on the targetPeer when it reaches the endpoint.
 void TunnelCreatorConfig.setPeer(int hop, Hash peer)
           
 void PumpedTunnelGateway.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 OutboundTunnelEndpoint.dispatch(TunnelDataMessage msg, Hash recvFrom)
           
 void OutboundMessageDistributor.distribute(I2NPMessage msg, Hash target)
           
 void OutboundMessageDistributor.distribute(I2NPMessage msg, Hash target, TunnelId tunnel)
           
 void InboundMessageDistributor.distribute(I2NPMessage msg, Hash target)
           
 void InboundMessageDistributor.distribute(I2NPMessage msg, Hash target, TunnelId tunnel)
           
 boolean InboundEndpointProcessor.retrievePreprocessedData(byte[] orig, int offset, int length, Hash prev)
          Undo all of the encryption done by the peers in the tunnel, recovering the preprocessed data sent by the gateway.
 boolean HopProcessor.process(byte[] orig, int offset, int length, Hash prev)
          Process the data for the current hop, overwriting the original data with what should be sent to the next peer.
 void HopConfig.setReceiveFrom(Hash from)
           
 void HopConfig.setSendTo(Hash to)
           
 boolean FragmentedMessage.receive(long messageId, byte[] payload, int offset, int length, boolean isLast, Hash toRouter, TunnelId toTunnel)
          Receive the first fragment and related metadata.
 void FragmentHandler.DefragmentedReceiver.receiveComplete(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)
          Receive a fully formed I2NPMessage out of the tunnel
 BuildRequestRecord BuildMessageProcessor.decrypt(I2PAppContext ctx, TunnelBuildMessage msg, Hash ourHash, PrivateKey privKey)
          Decrypt the record targetting us, encrypting all of the other records with the included reply key and IV.
 TunnelBuildMessage BuildMessageGenerator.createOutbound(RouterContext ctx, TunnelCreatorConfig cfg, Hash replyRouter, long replyTunnel)
          return null if it is unable to find a router's public key (etc)
 void BuildMessageGenerator.createRecord(int recordNum, int hop, TunnelBuildMessage msg, TunnelCreatorConfig cfg, Hash replyRouter, long replyTunnel, I2PAppContext ctx, PublicKey peerKey)
          Place the asymmetrically encrypted record in the specified record slot, containing the hop's configuration (as well as the reply info, if it is an outbound endpoint)
 

Constructors in net.i2p.router.tunnel with parameters of type Hash
TunnelGateway.Pending(I2NPMessage message, Hash toRouter, TunnelId toTunnel)
           
TunnelGateway.Pending(I2NPMessage message, Hash toRouter, TunnelId toTunnel, long now)
           
TunnelGateway.PendingImpl(I2NPMessage message, Hash toRouter, TunnelId toTunnel)
           
TunnelCreatorConfig(RouterContext ctx, int length, boolean isInbound, Hash destination)
           
InboundMessageDistributor(RouterContext ctx, Hash client)
           
 

Uses of Hash in net.i2p.router.tunnel.pool
 

Methods in net.i2p.router.tunnel.pool with parameters of type Hash
 TunnelInfo TunnelPoolManager.selectInboundTunnel(Hash destination)
          pick an inbound tunnel bound to the given destination
 TunnelInfo TunnelPoolManager.selectOutboundTunnel(Hash destination)
          pick an outbound tunnel bound to the given destination
 boolean TunnelPoolManager.isInUse(Hash peer)
           
 TunnelPoolSettings TunnelPoolManager.getInboundSettings(Hash client)
           
 TunnelPoolSettings TunnelPoolManager.getOutboundSettings(Hash client)
           
 void TunnelPoolManager.setInboundSettings(Hash client, TunnelPoolSettings settings)
           
 void TunnelPoolManager.setOutboundSettings(Hash client, TunnelPoolSettings settings)
           
 void TunnelPoolManager.removeTunnels(Hash destination)
           
 Job TunnelMessageHandlerBuilder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 Job HandleTunnelCreateMessageJob.Builder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)
           
 

Constructors in net.i2p.router.tunnel.pool with parameters of type Hash
PooledTunnelCreatorConfig(RouterContext ctx, int length, boolean isInbound, Hash destination)