## Uses of Class
net.i2p.data.Hash

Packages that use Hash
net.i2p.client: Implements the base I2P SDK for developing applications that communicate through I2P.
net.i2p.client.datagram: Provides a standard way for reading and writing messages transferred over I2P so that the recipient has an authenticated mechanism to reply to it.
net.i2p.client.naming: Provides a standard way for querying the local naming service to resolve a name into a `Destination` (without the complexity of JNDI).
net.i2p.client.streaming: Implements a TCP-like (reliable, authenticated, in order) set of sockets for communicating over the IP-like (unreliable, unauthenticated, unordered) I2P messages.
net.i2p.crypto: These classes provide a number of low-level cryptographic routines.
net.i2p.data: These classes define the common data structures used by the various I2P protocols.
net.i2p.data.i2cp: The Invisible Internet Client Protocol (I2CP) allows applications simplified access to the I2P network without requiring them to deal with the issues involved with the Invisible Internet Network Protocol (I2NP).
net.i2p.data.i2np: The Invisible Internet Network Protocol (I2NP) is only a part of how an application can send messages over the network.
net.i2p.router: The I2P router application handles the I2P network communication.
net.i2p.router.client
net.i2p.router.message
net.i2p.router.networkdb
net.i2p.router.networkdb.kademlia
net.i2p.router.peermanager: The peer manager logs information about the history and quality of network peers.
net.i2p.router.transport: The transport system allows the usage of communication layers that are below I2P in the stack, on which I2P messages are sent.
net.i2p.router.transport.ntcp: The NTCP transport allows passing I2P messages on top of TCP.
net.i2p.router.transport.udp: The UDP transport (also known as 'SSU transport') allows passing I2P messages on top of UDP.
net.i2p.router.tunnel
net.i2p.router.tunnel.pool
net.i2p.util: These classes define the several useful utilities used throughout the router and applications.
org.klomp.snark.dht

Uses of Hash in net.i2p.client

Methods in net.i2p.client with parameters of type Hash
`(package private) void` `I2PSessionImpl.destLookupFailed(Hash h)` called by the message handler
`Destination` `I2PSessionImpl.lookupDest(Hash h)` Blocking.
`Destination` `I2PSession.lookupDest(Hash h)` Lookup a Destination by Hash.
`Destination` `I2PSessionImpl.lookupDest(Hash h, long maxWait)` Blocking.
`Destination` `I2PSession.lookupDest(Hash h, long maxWait)` Blocking.

Uses of Hash in net.i2p.client.datagram

Methods in net.i2p.client.datagram that return Hash
`Hash` `I2PDatagramDissector.extractHash()` Extract the hash of the payload of an I2P repliable datagram (previously loaded with the loadI2PDatagram() method), without verifying the datagram signature.
`Hash` `I2PDatagramDissector.getHash()` Extract the hash of the payload of an I2P repliable datagram (previously loaded with the loadI2PDatagram() method), verifying the datagram signature.

Uses of Hash in net.i2p.client.naming

Methods in net.i2p.client.naming with parameters of type Hash
`Destination` `NamingService.lookup(Hash hash, int timeout)` Same as lookupB32 but with the SHA256 Hash precalculated
`String` `NamingService.reverseLookup(Hash h)` Deprecated. unused

Uses of Hash in net.i2p.client.streaming

Methods in net.i2p.client.streaming that return types with arguments of type Hash
`Set<Hash>` `ConnectionOptions.getAccessList()`
`Set<Hash>` `ConnectionOptions.getBlacklist()`

Methods in net.i2p.client.streaming with parameters of type Hash
`(package private) boolean` `ConnThrottler.shouldThrottle(Hash h)` increments before checking

Uses of Hash in net.i2p.crypto

Methods in net.i2p.crypto that return Hash
`Hash` `HMACGenerator.calculate(SessionKey key, byte[] data)` Deprecated. unused
`Hash` `SHA256Generator.calculateHash(byte[] source)` Calculate the SHA-256 hash of the source and cache the result.
`Hash` `SHA256Generator.calculateHash(byte[] source, int start, int len)` Calculate the hash and cache the result.

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

Uses of Hash in net.i2p.data

Fields in net.i2p.data declared as Hash
`protected Hash` `KeysAndCert.__calculatedHash`
`protected Hash` `DatabaseEntry._currentRoutingKey`
`static Hash` `Hash.FAKE_HASH`

Methods in net.i2p.data that return Hash
`Hash` `DataStructure.calculateHash()` Calculate the SHA256 value of this object (useful for a few scenarios)
`Hash` `DataStructureImpl.calculateHash()`
`Hash` `SimpleDataStructure.calculateHash()`
`Hash` `KeysAndCert.calculateHash()`
`static Hash` `Hash.create(byte[] data)` Pull from cache or return new
`static Hash` `Hash.create(byte[] data, int off)` Pull from cache or return new
`static Hash` `Hash.create(InputStream in)` Pull from cache or return new
`Hash` `Lease.getGateway()` Retrieve the router at which the destination can be contacted
`Hash` `DatabaseEntry.getHash()` A common interface to the Hash of the two subclasses.
`Hash` `KeysAndCert.getHash()`
`Hash` `DatabaseEntry.getRoutingKey()` Get the routing key for the structure using the current modifier in the RoutingKeyGenerator.
`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.

Methods in net.i2p.data that return types with arguments of type Hash
`Set<Hash>` `RouterInfo.getPeers()` Deprecated. Implemented here but unused elsewhere

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` `Lease.setGateway(Hash ident)` Configure the router at which the destination can be contacted
`void` `DatabaseEntry.setRoutingKey(Hash key)`

Method parameters in net.i2p.data with type arguments of type Hash
`void` `RouterInfo.setPeers(Set<Hash> peers)` Deprecated. Implemented here but unused elsewhere

Uses of Hash in net.i2p.data.i2cp

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

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

Constructors in net.i2p.data.i2cp with parameters of type Hash
`DestLookupMessage(Hash h)`
`DestReplyMessage(Hash h)`

Uses of Hash in net.i2p.data.i2np

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

Methods in net.i2p.data.i2np that return types with arguments of type Hash
`Set<Hash>` `DatabaseLookupMessage.getDontIncludePeers()` Set of peers that a lookup reply should NOT include

Methods in net.i2p.data.i2np with parameters of type Hash
`void` `DatabaseSearchReplyMessage.addReply(Hash peer)`
`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.
`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.encryptRecord(I2PAppContext ctx, PublicKey toKey, Hash toPeer, byte[] out, int outOffset)` Encrypt the record to the specified peer.
`boolean` `BuildRequestRecord.readOurIdentityMatches(Hash ourIdentity)` true if the identity they expect us to be is who we are
`void` `DeliveryInstructions.setDestination(Hash dest)`
`void` `DatabaseLookupMessage.setFrom(Hash from)`
`void` `DatabaseSearchReplyMessage.setFromHash(Hash from)`
`void` `DatabaseStoreMessage.setReplyGateway(Hash peer)`
`void` `DeliveryInstructions.setRouter(Hash router)`
`void` `DatabaseSearchReplyMessage.setSearchKey(Hash key)`
`void` `DatabaseLookupMessage.setSearchKey(Hash key)`

Uses of Hash in net.i2p.router

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

Methods in net.i2p.router that return types with arguments of type Hash
`Set<Hash>` `DummyNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)`
`abstract Set<Hash>` `NetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)` Return the RouterInfo structures for the routers closest to the given key.
`Set<Hash>` `DummyNetworkDatabaseFacade.getAllRouters()`
`abstract Set<Hash>` `NetworkDatabaseFacade.getAllRouters()`
`Map<Hash,Shitlist.Entry>` `Shitlist.getEntries()` for ShitlistRenderer in router console
`Map<Hash,TunnelPool>` `TunnelManagerFacade.getInboundClientPools()` for TunnelRenderer in router console
`Map<Hash,TunnelPool>` `DummyTunnelManagerFacade.getInboundClientPools()`
`Map<Hash,TunnelPool>` `TunnelManagerFacade.getOutboundClientPools()` for TunnelRenderer in router console
`Map<Hash,TunnelPool>` `DummyTunnelManagerFacade.getOutboundClientPools()`
`List<Hash>` `PeerManagerFacade.getPeersByCapability(char capability)`
`List<Hash>` `DummyPeerManagerFacade.getPeersByCapability(char capability)`
`List<Hash>` `PeerManagerFacade.selectPeers(PeerSelectionCriteria criteria)` Select peers from the manager's existing routing tables according to the specified criteria.
`List<Hash>` `DummyPeerManagerFacade.selectPeers(PeerSelectionCriteria criteria)`
`Set<Hash>` `TunnelManagerFacade.selectPeersInTooManyTunnels()`
`Set<Hash>` `DummyTunnelManagerFacade.selectPeersInTooManyTunnels()`

Methods in net.i2p.router with parameters of type Hash
`boolean` `RouterThrottleImpl.acceptNetDbLookupRequest(Hash key)` Deprecated. unused, function moved to netdb
`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)` Deprecated.
`int` `InNetMessagePool.add(I2NPMessage messageBody, RouterIdentity fromRouter, Hash fromRouterHash)` Add a new message to the pool.
`void` `ProfileManager.commErrorOccurred(Hash peer)` Note that there was some sort of communication error talking with the peer
`Job` `HandlerJobBuilder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)` Create a new job to handle the received message.
`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.dbLookupReceived(Hash peer)` Note that the local router received a db lookup from the given peer

`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.dbLookupSuccessful(Hash peer, long responseTimeMs)` Note that the peer was able to return the valid data for a db lookup
`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.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.dbStoreSuccessful(Hash peer)` Note that we confirmed a successful send of db data to the peer.
`void` `MessageHistory.droppedInboundMessage(long messageId, Hash from, String info)`
`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.droppedTunnelMessage(TunnelId id, long msgId, 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` `DummyNetworkDatabaseFacade.fail(Hash dbEntry)`
`abstract void` `NetworkDatabaseFacade.fail(Hash dbEntry)`
`Set<Hash>` `DummyNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)`
`abstract Set<Hash>` `NetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)` Return the RouterInfo structures for the routers closest to the given key.
`List<byte[]>` `Blocklist.getAddresses(Hash peer)` this tries to not return duplicates but I suppose it could.
`SessionKeyManager` `DummyClientManagerFacade.getClientSessionKeyManager(Hash _dest)`
`abstract SessionKeyManager` `ClientManagerFacade.getClientSessionKeyManager(Hash dest)`
`String` `CommSystemFacade.getCountry(Hash peer)`
`TunnelPoolSettings` `TunnelManagerFacade.getInboundSettings(Hash client)`
`TunnelPoolSettings` `DummyTunnelManagerFacade.getInboundSettings(Hash client)`
`byte[]` `CommSystemFacade.getIP(Hash dest)`
`LeaseSetKeys` `KeyManager.getKeys(Hash dest)`
`int` `TunnelManagerFacade.getOutboundClientTunnelCount(Hash destination)` how many outbound client tunnels in this pool?
`int` `DummyTunnelManagerFacade.getOutboundClientTunnelCount(Hash destination)`
`TunnelPoolSettings` `TunnelManagerFacade.getOutboundSettings(Hash client)`
`TunnelPoolSettings` `DummyTunnelManagerFacade.getOutboundSettings(Hash client)`
`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.heardAbout(Hash peer, long when)`
`boolean` `CommSystemFacade.isBacklogged(Hash dest)`
`boolean` `Blocklist.isBlocklisted(Hash peer)` Does the peer's IP address appear in the blocklist? If so, and it isn't shitlisted, shitlist it forever...
`boolean` `CommSystemFacade.isEstablished(Hash dest)`
`boolean` `DummyClientManagerFacade.isLocal(Hash destHash)`
`abstract boolean` `ClientManagerFacade.isLocal(Hash destHash)` Determine if the destination hash specified is managed locally.
`boolean` `Shitlist.isShitlisted(Hash peer)`
`boolean` `Shitlist.isShitlisted(Hash peer, String transport)`
`boolean` `Shitlist.isShitlistedForever(Hash peer)`
`boolean` `TunnelManagerFacade.isValidTunnel(Hash client, TunnelInfo tunnel)` Is a tunnel a valid member of the pool?
`boolean` `DummyTunnelManagerFacade.isValidTunnel(Hash client, TunnelInfo tunnel)`
`void` `DummyNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`abstract void` `NetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`LeaseSet` `DummyNetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)`
`abstract LeaseSet` `NetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)`
`DatabaseEntry` `DummyNetworkDatabaseFacade.lookupLocally(Hash key)`
`abstract DatabaseEntry` `NetworkDatabaseFacade.lookupLocally(Hash key)`
`void` `DummyNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`abstract void` `NetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`RouterInfo` `DummyNetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)`
`abstract RouterInfo` `NetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)`
`void` `ProfileManager.messageFailed(Hash peer)` Note that the router failed to send a message to the peer over any transport
`void` `ProfileManager.messageFailed(Hash peer, String transport)` Note that the router failed to send a message to the peer over the transport specified
`void` `ProfileManager.messageReceived(Hash peer, String style, long msToReceive, int bytesRead)` Note that the router received a message from the given peer on the specified transport.
`void` `ProfileManager.messageSent(Hash peer, String transport, long msToSend, long bytesSent)` Note that it took msToSend to send a message of size bytesSent to the peer over the transport.
`SessionKey` `PersistentKeyRing.put(Hash h, SessionKey sk)`
`void` `MessageHistory.receiveMessage(String messageType, long messageId, long expiration, Hash from, boolean isValid)` We just received a message from the peer
`SessionKey` `PersistentKeyRing.remove(Hash h)`
`void` `PeerManagerFacade.removeCapabilities(Hash peer)`
`void` `DummyPeerManagerFacade.removeCapabilities(Hash peer)`
`String` `CommSystemFacade.renderPeerHTML(Hash peer)`
`void` `DummyClientManagerFacade.requestLeaseSet(Hash dest, LeaseSet set)`
`abstract void` `ClientManagerFacade.requestLeaseSet(Hash dest, LeaseSet set)`
`TunnelInfo` `TunnelManagerFacade.selectInboundTunnel(Hash destination)` pick an inbound tunnel bound to the given destination
`TunnelInfo` `DummyTunnelManagerFacade.selectInboundTunnel(Hash destination)`
`TunnelInfo` `TunnelManagerFacade.selectOutboundTunnel(Hash destination)` pick an outbound tunnel bound to the given destination
`TunnelInfo` `DummyTunnelManagerFacade.selectOutboundTunnel(Hash destination)`
`void` `MessageHistory.sendMessage(String messageType, long messageId, long expiration, Hash peer, boolean sentOk, String info)` We just sent a message to the peer
`void` `PeerManagerFacade.setCapabilities(Hash peer, String caps)`
`void` `DummyPeerManagerFacade.setCapabilities(Hash peer, String caps)`
`void` `TunnelPoolSettings.setDestination(Hash dest)`
`void` `ClientMessage.setDestinationHash(Hash dest)`
`void` `MessageReceptionInfo.setFromPeer(Hash routerIdentityHash)`
`void` `TunnelManagerFacade.setInboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `DummyTunnelManagerFacade.setInboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `TunnelManagerFacade.setOutboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `DummyTunnelManagerFacade.setOutboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `Blocklist.shitlist(Hash peer)` We don't keep the comment field in-memory, so we have to go back out to the file to find it.
`void` `MessageHistory.shitlist(Hash peer, String reason)` We shitlisted the peer
`boolean` `Shitlist.shitlistRouter(Hash peer)`
`boolean` `Shitlist.shitlistRouter(Hash peer, String reason)`
`boolean` `Shitlist.shitlistRouter(Hash peer, String reason, String transport)`
`boolean` `Shitlist.shitlistRouter(Hash peer, String reason, String transport, boolean forever)`
`boolean` `Shitlist.shitlistRouter(String reasonCode, Hash peer, String reason)` ick have to put the reasonCode in the front to avoid ambiguity
`boolean` `Shitlist.shitlistRouterForever(Hash peer, String reason)`
`boolean` `Shitlist.shitlistRouterForever(Hash peer, String reason, String reasonCode)`
`boolean` `ClientManagerFacade.shouldPublishLeaseSet(Hash destinationHash)` Does the client specified want their leaseSet published?
`LeaseSet` `DummyNetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)`
`abstract LeaseSet` `NetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)` return the leaseSet if another leaseSet already existed at that key
`RouterInfo` `DummyNetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)`
`abstract RouterInfo` `NetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)` return the routerInfo if another router already existed at that key
`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` `MessageHistory.tunnelDispatched(long messageId, long tunnelId, long toTunnel, Hash toPeer, String type)`
`void` `ProfileManager.tunnelFailed(Hash peer, int pct)` Note that the peer participated in a tunnel that failed.
`void` `ProfileManager.tunnelJoined(Hash peer, long responseTimeMs)` Note that the router agreed to participate in a tunnel
`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` `MessageHistory.tunnelParticipantRejected(Hash peer, String msg)`
`void` `ProfileManager.tunnelRejected(Hash peer, long responseTimeMs, int severity)` Note that a router explicitly rejected joining a tunnel
`void` `MessageHistory.tunnelRejected(Hash peer, TunnelId tunnel, Hash replyThrough, String reason)` The peer did not accept the tunnel join for the given reason
`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` `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.tunnelTimedOut(Hash peer)` Note that a router timed out joining a tunnel
`void` `MessageHistory.unshitlist(Hash peer)` We unshitlisted the peer
`void` `Shitlist.unshitlistRouter(Hash peer)`
`void` `Shitlist.unshitlistRouter(Hash peer, String transport)`
`boolean` `CommSystemFacade.wasUnreachable(Hash dest)`

Method parameters in net.i2p.router with type arguments of type Hash
`Set<Hash>` `DummyNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)`
`abstract Set<Hash>` `NetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)` Return the RouterInfo structures for the routers closest to the given key.

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
`SessionKeyManager` `ClientManager.getClientSessionKeyManager(Hash dest)` Return the client's SessionKeyManager Use this instead of the RouterContext.sessionKeyManager() to prevent correlation attacks across destinations
`SessionKeyManager` `ClientManagerFacadeImpl.getClientSessionKeyManager(Hash dest)` Return the client's current manager or null if not connected
`boolean` `ClientManager.isLocal(Hash destHash)`
`boolean` `ClientManagerFacadeImpl.isLocal(Hash destHash)` Determine if the destination specified is managed locally.
`void` `ClientManager.requestLeaseSet(Hash dest, LeaseSet ls)`
`void` `ClientManagerFacadeImpl.requestLeaseSet(Hash dest, LeaseSet set)`
`boolean` `ClientManager.shouldPublishLeaseSet(Hash destHash)`
`boolean` `ClientManagerFacadeImpl.shouldPublishLeaseSet(Hash destinationHash)`

Constructors in net.i2p.router.client with parameters of type Hash
`LookupDestJob(RouterContext context, ClientConnectionRunner runner, Hash h)`

Uses of Hash in net.i2p.router.message

Methods in net.i2p.router.message with parameters of type Hash

`(package private) static GarlicMessage`

`OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, PayloadGarlicConfig dataClove, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, Set<SessionTag> 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) This is called from OCMOSJ

`(package private) static GarlicMessage`

`OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, Payload data, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, Set<SessionTag> wrappedTags, boolean requireAck, LeaseSet bundledReplyLeaseSet)`
Build a garlic message that will be delivered to the router on which the target is located.

`Job` `GarlicMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`static int` `GarlicMessageBuilder.estimateAvailableTags(RouterContext ctx, PublicKey key, Hash local)`

Constructors in net.i2p.router.message with parameters of type Hash
`GarlicMessageReceiver(RouterContext context, GarlicMessageReceiver.CloveReceiver receiver, Hash clientDestination)`
`HandleGarlicMessageJob(RouterContext context, GarlicMessage msg, RouterIdentity from, Hash fromHash)`
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, int timeoutMs, int priority)`
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, Job onSend, ReplyJob onSuccess, Job onFail, MessageSelector selector, int timeoutMs, int priority)`
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, ReplyJob onSuccess, Job onFail, MessageSelector selector, int 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)`
`protected void` `HandleDatabaseLookupMessageJob.sendClosest(Hash key, Set<Hash> routerHashes, Hash toPeer, TunnelId replyTunnel)`
`protected void` `HandleDatabaseLookupMessageJob.sendMessage(I2NPMessage message, Hash toPeer, TunnelId replyTunnel)`

Method parameters in net.i2p.router.networkdb with type arguments of type Hash
`protected void` `HandleDatabaseLookupMessageJob.sendClosest(Hash key, Set<Hash> routerHashes, Hash toPeer, TunnelId replyTunnel)`

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

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

Subclasses of Hash in net.i2p.router.networkdb.kademlia
`(package private) class` `LocalHash` Pull the caching used only by KBucketImpl out of Hash and put it here.

Fields in net.i2p.router.networkdb.kademlia declared as Hash
`protected Hash` `FloodSearchJob._key`
`(package private) Hash` `SingleSearchJob._to`

Methods in net.i2p.router.networkdb.kademlia that return Hash
`Hash` `KBucket.generateRandomKey()` Generate a random key that would go inside this bucket
`Hash` `KBucketImpl.generateRandomKey()` Generate a random key to go within this bucket WARNING - Something is seriously broken here.
`protected Hash` `FloodSearchJob.getKey()`
`Hash` `KBucketImpl.getRangeBeginKey()`
`Hash` `KBucketImpl.getRangeEndKey()`
`Hash` `StoreState.getTarget()`
`Hash` `SearchState.getTarget()`

Methods in net.i2p.router.networkdb.kademlia that return types with arguments of type Hash
`Set<Hash>` `KademliaNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)` Get the routers closest to that key in response to a remote lookup Only used by ../HDLMJ Set MAY INCLUDE our own router - add to peersToIgnore if you don't want
`Set<Hash>` `KBucketSet.getAll()`
`Set<Hash>` `KBucketSet.getAll(Set<Hash> toIgnore)`
`Set<Hash>` `KademliaNetworkDatabaseFacade.getAllRouters()` get the hashes for all known routers
`Set<Hash>` `StoreState.getAttempted()`
`Set<Hash>` `KBucket.getEntries()` Retrieve all routing table entries stored in the bucket
`Set<Hash>` `KBucketImpl.getEntries()`
`Set<Hash>` `KBucketImpl.getEntries(Set toIgnoreHashes)`
`Set<Hash>` `KBucket.getEntries(Set<Hash> toIgnoreHashes)` Retrieve hashes stored in the bucket, excluding the ones specified
`Set<Hash>` `KademliaNetworkDatabaseFacade.getExploreKeys()`
`Set<Hash>` `StoreState.getFailed()` public Set<Hash> getSuccessfulExploratory() { synchronized (_successfulExploratoryPeers) { return (Set<Hash>)_successfulExploratoryPeers.clone(); } }
`List<Hash>` `FloodfillNetworkDatabaseFacade.getFloodfillPeers()` list of the Hashes of currently known floodfill peers; Returned list will not include our own hash.
`Set<Hash>` `DataStore.getKeys()`
`Set<Hash>` `TransientDataStore.getKeys()`
`Set<Map.Entry<Hash,DatabaseEntry>>` `DataStore.getMapEntries()`
`Set<Map.Entry<Hash,DatabaseEntry>>` `TransientDataStore.getMapEntries()`
`Set<Hash>` `StoreState.getPending()`
`Set<Hash>` `StoreState.getSuccessful()`
`(package private) List<Hash>` `FloodfillPeerSelector.selectFloodfillParticipants(Hash key, int maxNumRouters, KBucketSet kbuckets)` Sort the floodfills.
`(package private) List<Hash>` `FloodfillPeerSelector.selectFloodfillParticipants(Hash key, int howMany, Set<Hash> toIgnore, KBucketSet kbuckets)` See above for description List will not include our own hash
`(package private) List<Hash>` `FloodfillPeerSelector.selectFloodfillParticipants(KBucketSet kbuckets)`
`(package private) List<Hash>` `PeerSelector.selectMostReliablePeers(Hash key, int numClosest, Set<Hash> alreadyChecked, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Search through the kbucket set to find the most reliable peers close to the given key, skipping all of the ones already checked List will not include our own hash.
`(package private) List<Hash>` `FloodfillPeerSelector.selectMostReliablePeers(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`(package private) List<Hash>` `PeerSelector.selectNearest(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Generic KBucket filtering to find the hashes close to a key, regardless of other considerations.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearest(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Floodfill peers only.
`(package private) List<Hash>` `PeerSelector.selectNearestExplicit(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Ignore KBucket ordering and do the XOR explicitly per key.
`(package private) List<Hash>` `PeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Ignore KBucket ordering and do the XOR explicitly per key.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets, boolean preferConnected)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.

Methods in net.i2p.router.networkdb.kademlia with parameters of type Hash
`(package private) boolean` `SearchJob.add(Hash peer)`
`int` `KBucket.add(Hash key)` Add the peer to the bucket
`void` `SelectionCollector.add(Hash entry)`
`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
`int` `KBucketImpl.add(Hash peer)` Todo: shuffling here is a hack and doesn't work since we switched back to a HashSet implementation
`void` `StoreState.addPending(Hash peer)`
`void` `SearchState.addPending(Hash peer)`
`void` `StoreState.addPending(Hash peer, MessageWrapper.WrappedMessage msg)`
`void` `StoreState.addSkipped(Hash peer)` we aren't even going to try to contact this peer
`protected DatabaseLookupMessage` `SearchJob.buildMessage(TunnelId replyTunnelId, Hash replyGateway, long expiration)` Build the database search message
`protected DatabaseLookupMessage` `ExploreJob.buildMessage(TunnelId replyTunnelId, Hash replyGateway, long expiration)` Build the database search message, but unlike the normal searches, we're more explicit in what we /dont/ want.
`byte[]` `LocalHash.cachedXor(Hash key)` Calculate the xor with the current object and the specified hash, caching values where possible.
`int` `XORComparator.compare(Hash lhs, Hash rhs)`
`(package private) void` `FloodfillNetworkDatabaseFacade.complete(Hash key)`
`long` `StoreState.confirmed(Hash peer)`
`Job` `FloodfillDatabaseStoreMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`Job` `FloodfillDatabaseLookupMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`long` `SearchState.dataFound(Hash peer)` how long did it take to get the reply, or -1 if we don't know
`(package private) void` `FloodOnlySearchJob.decrementRemaining(Hash peer)` Note that we heard from the peer
`protected void` `KademliaNetworkDatabaseFacade.dropAfterLookupFailed(Hash peer, RouterInfo info)`
`void` `KademliaNetworkDatabaseFacade.fail(Hash dbEntry)`
`Set<Hash>` `KademliaNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)` Get the routers closest to that key in response to a remote lookup Only used by ../HDLMJ Set MAY INCLUDE our own router - add to peersToIgnore if you don't want
`DatabaseEntry` `DataStore.get(Hash key)`
`DatabaseEntry` `TransientDataStore.get(Hash key)`
`DatabaseEntry` `PersistentDataStore.get(Hash key)`
`DatabaseEntry` `DataStore.get(Hash key, boolean persist)`
`DatabaseEntry` `TransientDataStore.get(Hash key, boolean persist)` for PersistentDataStore only - don't use here @throws IAE always
`DatabaseEntry` `PersistentDataStore.get(Hash key, boolean persist)` Prepare for having only a partial set in memory and the rest on disk
`static BigInteger` `HashDistance.getDistance(Hash targetKey, Hash routerInQuestion)`
`int` `KademliaNetworkDatabaseFacade.getPeerTimeout(Hash peer)` todo: does this need more tuning?
`MessageWrapper.WrappedMessage` `StoreState.getPendingMessage(Hash peer)`
`protected int` `SearchJob.getPerPeerTimeoutMs(Hash peer)`
`boolean` `DataStore.isKnown(Hash key)`
`boolean` `TransientDataStore.isKnown(Hash key)`
`(package private) boolean` `FloodfillNetworkDatabaseFacade.isVerifyInProgress(Hash h)`
`protected void` `FloodfillNetworkDatabaseFacade.lookupBeforeDropping(Hash peer, RouterInfo info)` Search for a newer router info, drop it from the db if the search fails, unless just started up or have bigger problems.
`protected void` `KademliaNetworkDatabaseFacade.lookupBeforeDropping(Hash peer, RouterInfo info)` don't use directly - see F.N.D.F.
`void` `KademliaNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`LeaseSet` `KademliaNetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)`
`DatabaseEntry` `KademliaNetworkDatabaseFacade.lookupLocally(Hash key)`
`void` `KademliaNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`RouterInfo` `KademliaNetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)`
`int` `KBucketSet.pickBucket(Hash key)`
`boolean` `DataStore.put(Hash key, DatabaseEntry data)`
`boolean` `TransientDataStore.put(Hash key, DatabaseEntry data)`
`boolean` `PersistentDataStore.put(Hash key, DatabaseEntry data)`
`boolean` `DataStore.put(Hash key, DatabaseEntry data, boolean persist)`
`boolean` `TransientDataStore.put(Hash key, DatabaseEntry data, boolean persist)` for PersistentDataStore only - don't use here @throws IAE always
`boolean` `PersistentDataStore.put(Hash key, DatabaseEntry data, boolean persist)`
`DatabaseEntry` `DataStore.remove(Hash key)`
`boolean` `KBucket.remove(Hash key)` Remove the key from the bucket
`boolean` `KBucketSet.remove(Hash entry)`
`boolean` `KBucketImpl.remove(Hash peer)`
`DatabaseEntry` `TransientDataStore.remove(Hash key)`
`DatabaseEntry` `PersistentDataStore.remove(Hash key)`
`DatabaseEntry` `DataStore.remove(Hash key, boolean persist)`
`DatabaseEntry` `TransientDataStore.remove(Hash key, boolean persist)` for PersistentDataStore only - don't use here
`DatabaseEntry` `PersistentDataStore.remove(Hash key, boolean persist)`
`void` `SearchState.removePending(Hash peer)` we didn't actually want to add this peer as part of the pending list...

`(package private) void`

`SearchJob.replyFound(DatabaseSearchReplyMessage message, Hash peer)`
always send through the lease protected DatabaseLookupMessage buildMessage(long expiration) { DatabaseLookupMessage msg = new DatabaseLookupMessage(getContext(), true); msg.setSearchKey(_state.getTarget()); msg.setFrom(getContext().routerHash()); msg.setDontIncludePeers(_state.getClosestAttempted(MAX_CLOSEST)); msg.setMessageExpiration(expiration); msg.setReplyTunnel(null); return msg; }

`long` `SearchState.replyFound(Hash peer)` how long did it take to get the reply, or -1 if we dont know
`void` `StoreState.replyTimeout(Hash peer)` public long confirmedExploratory(Hash peer) { long rv = -1; synchronized (_pendingPeers) { _pendingPeers.remove(peer); Long when = _pendingPeerTimes.remove(peer); if (when != null) rv = _context.clock().now() - when.longValue(); } synchronized (_successfulExploratoryPeers) { _successfulExploratoryPeers.add(peer); } return rv; }
`void` `SearchState.replyTimeout(Hash peer)`
`(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) 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) Unused - called only by FNDF.searchFull() from FloodSearchJob which is overridden - don't use this.

`(package private) void` `KademliaNetworkDatabaseFacade.searchComplete(Hash key)` The search for the given key is no longer active
`(package private) void` `FloodfillNetworkDatabaseFacade.searchFull(Hash key, List<Job> onFind, List<Job> 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 Unused - called only by FloodSearchJob which is overridden - don't use this.
`(package private) List<Hash>` `FloodfillPeerSelector.selectFloodfillParticipants(Hash key, int maxNumRouters, KBucketSet kbuckets)` Sort the floodfills.
`(package private) List<Hash>` `FloodfillPeerSelector.selectFloodfillParticipants(Hash key, int howMany, Set<Hash> toIgnore, KBucketSet kbuckets)` See above for description List will not include our own hash
`(package private) List<Hash>` `PeerSelector.selectMostReliablePeers(Hash key, int numClosest, Set<Hash> alreadyChecked, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Search through the kbucket set to find the most reliable peers close to the given key, skipping all of the ones already checked List will not include our own hash.
`(package private) List<Hash>` `FloodfillPeerSelector.selectMostReliablePeers(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`(package private) List<Hash>` `PeerSelector.selectNearest(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Generic KBucket filtering to find the hashes close to a key, regardless of other considerations.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearest(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Floodfill peers only.
`(package private) List<Hash>` `PeerSelector.selectNearestExplicit(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Ignore KBucket ordering and do the XOR explicitly per key.
`(package private) List<Hash>` `PeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Ignore KBucket ordering and do the XOR explicitly per key.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets, boolean preferConnected)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`protected void` `HandleFloodfillDatabaseLookupMessageJob.sendClosest(Hash key, Set<Hash> routerInfoSet, Hash toPeer, TunnelId replyTunnel)` We extend this here to send our routerInfo back as well, if we are not floodfill.
`void` `FloodfillNetworkDatabaseFacade.sendStore(Hash key, DatabaseEntry ds, Job onSuccess, Job onFailure, long sendTimeout, Set toIgnore)`
`void` `KademliaNetworkDatabaseFacade.sendStore(Hash key, DatabaseEntry ds, Job onSuccess, Job onFailure, long sendTimeout, Set toIgnore)` unused (overridden in FNDF)
`boolean` `KBucket.shouldContain(Hash key)` whether or not the key qualifies as part of this bucket
`boolean` `KBucketImpl.shouldContain(Hash key)`
`(package private) boolean` `FloodThrottler.shouldThrottle(Hash h)` increments before checking
`(package private) boolean` `LookupThrottler.shouldThrottle(Hash key, TunnelId id)` increments before checking
`(package private) boolean` `FloodfillNetworkDatabaseFacade.shouldThrottleFlood(Hash key)` Increments and tests.
`(package private) boolean` `FloodfillNetworkDatabaseFacade.shouldThrottleLookup(Hash from, TunnelId id)` Increments and tests.
`(package private) void` `KademliaNetworkDatabaseFacade.stopPublishing(Hash target)`
`LeaseSet` `KademliaNetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)` Store the leaseSet
`RouterInfo` `KademliaNetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)` store the routerInfo
`RouterInfo` `KademliaNetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo, boolean persist)`
`(package private) String` `KademliaNetworkDatabaseFacade.validate(Hash key, LeaseSet leaseSet)` Determine whether this leaseSet will be accepted as valid and current given what we know now.
`(package private) String` `KademliaNetworkDatabaseFacade.validate(Hash key, RouterInfo routerInfo)` Determine whether this routerInfo will be accepted as valid and current given what we know now.
`(package private) void` `FloodfillNetworkDatabaseFacade.verifyFinished(Hash h)`
`(package private) void` `FloodfillNetworkDatabaseFacade.verifyStarted(Hash h)`
`(package private) boolean` `SearchJob.wasAttempted(Hash peer)`
`boolean` `SearchState.wasAttempted(Hash peer)`
`(package private) static MessageWrapper.WrappedMessage` `MessageWrapper.wrap(RouterContext ctx, I2NPMessage m, Hash from, RouterInfo to)` Garlic wrap a message from a client or this router, destined for a router, to hide the contents from the OBEP.

Method parameters in net.i2p.router.networkdb.kademlia with type arguments of type Hash
`void` `StoreState.addPending(Collection<Hash> pending)`
`Set<Hash>` `KademliaNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, Set<Hash> peersToIgnore)` Get the routers closest to that key in response to a remote lookup Only used by ../HDLMJ Set MAY INCLUDE our own router - add to peersToIgnore if you don't want
`Set<Hash>` `KBucketSet.getAll(Set<Hash> toIgnore)`
`Set<Hash>` `KBucket.getEntries(Set<Hash> toIgnoreHashes)` Retrieve hashes stored in the bucket, excluding the ones specified
`(package private) List<Hash>` `FloodfillPeerSelector.selectFloodfillParticipants(Hash key, int howMany, Set<Hash> toIgnore, KBucketSet kbuckets)` See above for description List will not include our own hash
`(package private) List<Hash>` `PeerSelector.selectMostReliablePeers(Hash key, int numClosest, Set<Hash> alreadyChecked, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Search through the kbucket set to find the most reliable peers close to the given key, skipping all of the ones already checked List will not include our own hash.
`(package private) List<Hash>` `FloodfillPeerSelector.selectMostReliablePeers(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`(package private) List<Hash>` `PeerSelector.selectNearest(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Generic KBucket filtering to find the hashes close to a key, regardless of other considerations.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearest(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Floodfill peers only.
`(package private) List<Hash>` `PeerSelector.selectNearestExplicit(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Ignore KBucket ordering and do the XOR explicitly per key.
`(package private) List<Hash>` `PeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` UNUSED - See FloodfillPeerSelector override Ignore KBucket ordering and do the XOR explicitly per key.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`(package private) List<Hash>` `FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, Set<Hash> peersToIgnore, KBucketSet kbuckets, boolean preferConnected)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`protected void` `HandleFloodfillDatabaseLookupMessageJob.sendClosest(Hash key, Set<Hash> routerInfoSet, Hash toPeer, TunnelId replyTunnel)` We extend this here to send our routerInfo back as well, if we are not floodfill.
`void` `KBucket.setEntries(Set<Hash> entries)` Fill the bucket with entries
`void` `KBucketImpl.setEntries(Set<Hash> entries)`

Constructors in net.i2p.router.networkdb.kademlia with parameters of type Hash
`ExploreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key)` Create a new search for the routingKey specified
`FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs)` Send a data structure to the floodfills
`FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs, Set<Hash> toSkip)`
`FloodfillVerifyStoreJob(RouterContext ctx, Hash key, long published, boolean isRouterInfo, Hash sentTo, FloodfillNetworkDatabaseFacade facade)` Delay a few seconds, then start the verify
`FloodOnlySearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)`
`FloodSearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)`
`HandleFloodfillDatabaseLookupMessageJob(RouterContext ctx, DatabaseLookupMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`HandleFloodfillDatabaseStoreMessageJob(RouterContext ctx, DatabaseStoreMessage receivedMessage, RouterIdentity from, Hash fromHash, FloodfillNetworkDatabaseFacade facade)`
`KBucketImpl(I2PAppContext context, Hash local)` for testing - use above constructor for production to get common caching
`KBucketSet(I2PAppContext context, Hash us)`
`LocalHash(Hash h)`
`RepublishLeaseSetJob(RouterContext ctx, KademliaNetworkDatabaseFacade facade, Hash destHash)`
`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
`SearchReplyJob(RouterContext enclosingContext, SearchJob job, DatabaseSearchReplyMessage message, Hash peer, long duration)`
`SearchState(RouterContext context, Hash key)`
`SingleSearchJob(RouterContext ctx, Hash key, Hash to)`
`StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs)` Send a data structure to the floodfills
`StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs, Set<Hash> toSkip)`
`StoreState(RouterContext ctx, Hash key, DatabaseEntry data)`
`StoreState(RouterContext ctx, Hash key, DatabaseEntry data, Set<Hash> toSkip)`
`XORComparator(Hash target)`

Constructor parameters in net.i2p.router.networkdb.kademlia with type arguments of type Hash
`FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs, Set<Hash> toSkip)`
`StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs, Set<Hash> toSkip)`
`StoreState(RouterContext ctx, Hash key, DatabaseEntry data, Set<Hash> toSkip)`

Uses of Hash in net.i2p.router.peermanager

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

Methods in net.i2p.router.peermanager that return types with arguments of type Hash
`List<Hash>` `PeerManagerFacadeImpl.getPeersByCapability(char capability)`
`List<Hash>` `PeerManager.getPeersByCapability(char capability)` The only user of this is TunnelPeerSelector for unreachables?
`Set<Hash>` `ProfileOrganizer.selectAllPeers()` Find the hashes for all peers we are actively profiling
`List<Hash>` `PeerManagerFacadeImpl.selectPeers(PeerSelectionCriteria criteria)`
`(package private) List<Hash>` `PeerManager.selectPeers(PeerSelectionCriteria criteria)` Find some peers that meet the criteria and we have the netDb info for locally Only used by PeerTestJob (PURPOSE_TEST)
`List<Hash>` `ProfileOrganizer.selectPeersLocallyUnreachable()` Get the peers the transport layer thinks are unreachable, and add in the peers with the SSU peer testing bug, and peers requiring introducers.
`List<Hash>` `ProfileOrganizer.selectPeersRecentlyRejecting()` Get the peers that have recently rejected us for bandwidth recent == last 20s

Methods in net.i2p.router.peermanager with parameters of type Hash
`void` `ProfileManagerImpl.commErrorOccurred(Hash peer)` Note that there was some sort of communication error talking with the peer
`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 This will force creation of DB stats
`void` `ProfileManagerImpl.dbLookupReceived(Hash peer)` Note that the local router received a db lookup from the given peer

`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.dbLookupSuccessful(Hash peer, long responseTimeMs)` Note that the peer was able to return the valid data for a db lookup This will force creation of DB stats
`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 This will force creation of DB stats
`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) This is not really interesting, since they could be lying, so we do not increment any DB stats at all.
`void` `ProfileManagerImpl.dbStoreSuccessful(Hash peer)` Note that we've verified a successful send of db data to the floodfill peer by querying another floodfill.
`boolean` `ProfileOrganizer.exportProfile(Hash profile, OutputStream out)`
`PeerProfile` `ProfileOrganizer.getProfile(Hash peer)` Retrieve the profile for the given peer, if one exists (else null)
`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.heardAbout(Hash peer, long when)` Note that the local router received a reference to the given peer at a certain time.
`boolean` `ProfileOrganizer.isFailing(Hash peer)`
`boolean` `ProfileOrganizer.isFast(Hash peer)`
`boolean` `ProfileOrganizer.isHighCapacity(Hash peer)`
`boolean` `ProfileOrganizer.isSelectable(Hash peer)`
`boolean` `ProfileOrganizer.isWellIntegrated(Hash peer)`
`void` `ProfileManagerImpl.messageFailed(Hash peer)` Note that the router failed to send a message to the peer over any transport
`void` `ProfileManagerImpl.messageFailed(Hash peer, String transport)` Note that the router failed to send a message to the peer over the transport specified
`void` `ProfileManagerImpl.messageReceived(Hash peer, String style, long msToReceive, int bytesRead)` Note that the router received a message from the given peer on the specified transport.
`void` `ProfileManagerImpl.messageSent(Hash peer, String transport, long msToSend, long bytesSent)` Note that it took msToSend to send a message of size bytesSent to the peer over the transport.
`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` `PeerManagerFacadeImpl.removeCapabilities(Hash peer)`
`void` `PeerManager.removeCapabilities(Hash peer)`
`void` `ProfileOrganizer.selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, Hash randomKey, int subTierMode)` Return a set of Hashes for peers that are both fast and reliable.
`void` `PeerManagerFacadeImpl.setCapabilities(Hash peer, String caps)`
`void` `PeerManager.setCapabilities(Hash peer, String caps)`
`void` `ProfileOrganizer.setUs(Hash us)`
`void` `ProfilePersistenceHelper.setUs(Hash routerIdentHash)`
`(package private) void` `PeerManager.storeProfile(Hash peer)`
`void` `ProfileManagerImpl.tunnelDataPushed(Hash peer, long rtt, int size)`
`void` `ProfileManagerImpl.tunnelDataPushed1m(Hash peer, int size)`
`void` `ProfileManagerImpl.tunnelFailed(Hash peer, int pct)` Note that the peer participated in a tunnel that failed.
`void` `ProfileManagerImpl.tunnelJoined(Hash peer, long responseTimeMs)` Note that the router agreed to participate in a tunnel
`void` `ProfileManagerImpl.tunnelLifetimePushed(Hash peer, long lifetime, long size)`
`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.tunnelTimedOut(Hash peer)` Note that a router did not respond to a tunnel join.

Method parameters in net.i2p.router.peermanager with type arguments of type Hash
`void` `ProfileOrganizer.selectActiveNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are both not failing and we're actively talking with.
`void` `ProfileOrganizer.selectActiveNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are both not failing and we're actively talking with.
`void` `ProfileOrganizer.selectAllNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing)` Return a set of Hashes for peers that are not failing.
`void` `ProfileOrganizer.selectAllNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing)` Return a set of Hashes for peers that are not failing.
`void` `ProfileOrganizer.selectFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` I'm not quite sure why you'd want this...
`void` `ProfileOrganizer.selectFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` I'm not quite sure why you'd want this...
`void` `ProfileOrganizer.selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are both fast and reliable.
`void` `ProfileOrganizer.selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are both fast and reliable.
`void` `ProfileOrganizer.selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, Hash randomKey, int subTierMode)` Return a set of Hashes for peers that are both fast and reliable.
`void` `ProfileOrganizer.selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, Hash randomKey, int subTierMode)` Return a set of Hashes for peers that are both fast and reliable.
`void` `ProfileOrganizer.selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)` Return a set of Hashes for peers that are both fast and reliable.
`void` `ProfileOrganizer.selectFastPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)` Return a set of Hashes for peers that are both fast and reliable.
`void` `ProfileOrganizer.selectHighCapacityPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that have a high capacity
`void` `ProfileOrganizer.selectHighCapacityPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that have a high capacity
`void` `ProfileOrganizer.selectHighCapacityPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)`
`void` `ProfileOrganizer.selectHighCapacityPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)`
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are not failing, preferring ones that we are already talking with
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are not failing, preferring ones that we are already talking with
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing)`
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing)`
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing, int mask)` Return a set of Hashes for peers that are not failing, preferring ones that we are already talking with
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, boolean onlyNotFailing, int mask)` Return a set of Hashes for peers that are not failing, preferring ones that we are already talking with
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)`
`void` `ProfileOrganizer.selectNotFailingPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)`
`void` `ProfileOrganizer.selectWellIntegratedPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are well integrated into the network.
`void` `ProfileOrganizer.selectWellIntegratedPeers(int howMany, Set<Hash> exclude, Set<Hash> matches)` Return a set of Hashes for peers that are well integrated into the network.
`void` `ProfileOrganizer.selectWellIntegratedPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)` Return a set of Hashes for peers that are well integrated into the network.
`void` `ProfileOrganizer.selectWellIntegratedPeers(int howMany, Set<Hash> exclude, Set<Hash> matches, int mask)` Return a set of Hashes for peers that are well integrated into the network.

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
`String` `CommSystemFacadeImpl.getCountry(Hash peer)` Uses the transport IP first because that lookup is fast, then the SSU IP from the netDb.
`byte[]` `CommSystemFacadeImpl.getIP(Hash dest)`
`static byte[]` `TransportImpl.getIP(Hash peer)`
`byte[]` `TransportManager.getIP(Hash dest)` IP of the peer from the last connection (in or out, any transport).
`boolean` `CommSystemFacadeImpl.isBacklogged(Hash dest)`
`boolean` `Transport.isBacklogged(Hash dest)`
`boolean` `TransportImpl.isBacklogged(Hash dest)`
`boolean` `TransportManager.isBacklogged(Hash dest)`
`boolean` `CommSystemFacadeImpl.isEstablished(Hash dest)`
`boolean` `Transport.isEstablished(Hash peer)`
`boolean` `TransportImpl.isEstablished(Hash dest)`
`boolean` `TransportManager.isEstablished(Hash dest)`
`boolean` `Transport.isUnreachable(Hash peer)`
`boolean` `TransportImpl.isUnreachable(Hash peer)`
`void` `TransportImpl.markReachable(Hash peer, boolean isInbound)` called when we establish a peer connection (outbound or inbound)
`void` `TransportImpl.markUnreachable(Hash peer)` This isn't very useful since it is cleared when they contact us
`void` `TransportImpl.markWasUnreachable(Hash peer, boolean yes)` Maintain the WasUnreachable list
`void` `TransportEventListener.messageReceived(I2NPMessage message, RouterIdentity fromRouter, Hash fromRouterHash)`
`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` `VMCommSystem.receive(byte[] message, Hash fromPeer)` We send messages between comms as bytes so that we strip any router-local info.
`String` `CommSystemFacadeImpl.renderPeerHTML(Hash peer)` Provide a consistent "look" for displaying router IDs in the console
`void` `TransportImpl.setIP(Hash peer, byte[] ip)`
`boolean` `CommSystemFacadeImpl.wasUnreachable(Hash dest)`
`boolean` `Transport.wasUnreachable(Hash dest)`
`boolean` `TransportImpl.wasUnreachable(Hash peer)` Was the peer UNreachable (outbound only) the last time we tried it? This is NOT reset if the peer contacts us and it is never expired.
`boolean` `TransportManager.wasUnreachable(Hash dest)` Was the peer UNreachable (outbound only) on any transport, based on the last time we tried it for each transport? This is NOT reset if the peer contacts us.

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

Methods in net.i2p.router.transport.ntcp with parameters of type Hash
`boolean` `NTCPTransport.isBacklogged(Hash dest)`
`boolean` `NTCPTransport.isEstablished(Hash dest)`

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

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

Methods in net.i2p.router.transport.udp that return types with arguments of type Hash
`List<Hash>` `UDPTransport._getActivePeers()` internal, do not use** return the peers (Hash) of active peers.

Methods in net.i2p.router.transport.udp with parameters of type Hash
`void` `OutboundMessageFragments.acked(ACKBitfield bitfield, Hash ackedBy)`
`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.ActiveThrottle.choke(Hash peer)`
`void` `TimedWeightedPriorityMessageQueue.choke(Hash peer)`
`void` `DummyThrottle.choke(Hash peer)`
`(package private) void` `UDPTransport.dropPeer(Hash peer, boolean shouldShitlist, String why)`
`(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
`boolean` `OutboundMessageFragments.ActiveThrottle.isChoked(Hash peer)`
`boolean` `TimedWeightedPriorityMessageQueue.isChoked(Hash peer)`
`boolean` `DummyThrottle.isChoked(Hash peer)`
`boolean` `UDPTransport.isEstablished(Hash dest)`
`void` `UDPTransport.messageReceived(I2NPMessage inMsg, RouterIdentity remoteIdent, Hash remoteIdentHash, long msToReceive, int bytesReceived)` infinite loop public RouterAddress getCurrentAddress() { if (needsRebuild()) rebuildExternalAddress(false); return super.getCurrentAddress(); }
`void` `PeerState.setRemotePeer(Hash peer)` The peer are we talking to.
`void` `OutboundMessageFragments.ActiveThrottle.unchoke(Hash peer)`
`void` `TimedWeightedPriorityMessageQueue.unchoke(Hash peer)`
`void` `DummyThrottle.unchoke(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` `TunnelCreatorConfig.getDestination()` if this is a client tunnel, what destination is it for?
`Hash` `InboundEndpointProcessor.getDestination()`
`Hash` `TunnelCreatorConfig.getPeer(int hop)` retrieve the peer at the given hop.
`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()`
`Hash` `TunnelGateway.Pending.getToRouter()` may be null

Methods in net.i2p.router.tunnel with parameters of type Hash
`void` `ThrottledPumpedTunnelGateway.add(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)` Possibly drop a message due to bandwidth before adding it to the preprocessor queue.
`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` `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` `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).
`static 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)
`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.
`void` `OutboundTunnelEndpoint.dispatch(TunnelDataMessage msg, Hash recvFrom)`
`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` `TunnelParticipant.dispatch(TunnelDataMessage msg, Hash recvFrom)`
`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` `OutboundMessageDistributor.distribute(I2NPMessage msg, Hash target)`
`void` `InboundMessageDistributor.distribute(I2NPMessage msg, Hash target)`
`void` `OutboundMessageDistributor.distribute(I2NPMessage msg, Hash target, TunnelId tunnel)`
`void` `InboundMessageDistributor.distribute(I2NPMessage msg, Hash target, TunnelId tunnel)`
`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.
`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
`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.
`void` `TunnelCreatorConfig.setPeer(int hop, Hash peer)`
`void` `HopConfig.setReceiveFrom(Hash from)`
`void` `HopConfig.setSendTo(Hash to)`

Constructors in net.i2p.router.tunnel with parameters of type Hash
`InboundMessageDistributor(RouterContext ctx, Hash client)`
`TunnelCreatorConfig(RouterContext ctx, int length, boolean isInbound, Hash destination)`
`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)`

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

Methods in net.i2p.router.tunnel.pool that return types with arguments of type Hash
`Set<Hash>` `TunnelPeerSelector.getExclude(RouterContext ctx, boolean isInbound, boolean isExploratory)` Pick peers that we want to avoid
`Map<Hash,TunnelPool>` `TunnelPoolManager.getInboundClientPools()` for TunnelRenderer in router console
`Map<Hash,TunnelPool>` `TunnelPoolManager.getOutboundClientPools()` for TunnelRenderer in router console
`protected List<Hash>` `TunnelPeerSelector.selectExplicit(RouterContext ctx, TunnelPoolSettings settings, int length)` For debugging, also possibly for restricted routes? Needs analysis and testing
`List<Hash>` `ClientPeerSelector.selectPeers(RouterContext ctx, TunnelPoolSettings settings)`
`abstract List<Hash>` `TunnelPeerSelector.selectPeers(RouterContext ctx, TunnelPoolSettings settings)` Which peers should go into the next tunnel for the given settings?
`List<Hash>` `ExploratoryPeerSelector.selectPeers(RouterContext ctx, TunnelPoolSettings settings)`
`Set<Hash>` `TunnelPoolManager.selectPeersInTooManyTunnels()` For reliability reasons, don't allow a peer in more than x% of client and exploratory tunnels.

Methods in net.i2p.router.tunnel.pool with parameters of type Hash
`TunnelPoolSettings` `TunnelPoolManager.getInboundSettings(Hash client)`
`int` `TunnelPoolManager.getOutboundClientTunnelCount(Hash destination)` Use to verify a tunnel pool is alive
`TunnelPoolSettings` `TunnelPoolManager.getOutboundSettings(Hash client)`
`boolean` `TunnelPoolManager.isValidTunnel(Hash client, TunnelInfo tunnel)`
`protected void` `TunnelPeerSelector.orderPeers(List rv, Hash hash)`
`void` `TunnelPoolManager.removeTunnels(Hash destination)` synch with buildTunnels() above
`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
`void` `TunnelPoolManager.setInboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `TunnelPoolManager.setOutboundSettings(Hash client, TunnelPoolSettings settings)`
`(package private) boolean` `ParticipatingThrottler.shouldThrottle(Hash h)` increments before checking

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

Uses of Hash in net.i2p.util

Methods in net.i2p.util that return Hash
`static Hash` `ConvertToHash.getHash(String peer)` Convert any kind of destination String to a hash

Uses of Hash in org.klomp.snark.dht

Methods in org.klomp.snark.dht that return types with arguments of type Hash
`List<Hash>` `DHT.getPeers(byte[] ih, int max, long maxWait)` Get peers for a torrent.