## 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)`
`void` `Shitlist.unshitlistRouter(Hash peer)`
`boolean` `Shitlist.isShitlisted(Hash peer)`
`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
`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()`

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 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)`
`(package private) void` `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)`
`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)`
`XORComparator(Hash target)`
`StoreState(RouterContext ctx, Hash key, DataStructure data)`
`StoreState(RouterContext ctx, Hash key, DataStructure data, java.util.Set toSkip)`
`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)`
`SearchState(RouterContext context, Hash key)`
`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)`
`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
`void` `TransportEventListener.messageReceived(I2NPMessage message, RouterIdentity fromRouter, Hash fromRouterHash)`
`void` `OutboundMessageRegistry.peerFailed(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)`
`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` `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)`
`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)`