PeerNode (fred API)

java.lang.Object
- freenet.node.PeerNode

All Implemented Interfaces:

USKRetrieverCallback, PeerContext, BasePeerNode

Direct Known Subclasses:

DarknetPeerNode, OpennetPeerNode, SeedClientPeerNode, SeedServerPeerNode
```
public abstract class PeerNode
extends java.lang.Object
implements USKRetrieverCallback, BasePeerNode
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class PeerNode.IncomingLoadSummaryStats

static class PeerNode.SlotWaiter

Nested Classes
Modifier and Type	Class and Description
`class`	`PeerNode.IncomingLoadSummaryStats`
`static class`	`PeerNode.SlotWaiter`

Field Summary

Fields
Modifier and Type	Field and Description
`RunningAverage`	`backedOffPercent`
`RunningAverage`	`backedOffPercentBulk`
`RunningAverage`	`backedOffPercentRT`
`static double`	`BLACK_MAGIC_BACKOFF_PRUNING_PERCENTAGE`
`static long`	`BLACK_MAGIC_BACKOFF_PRUNING_TIME` Some alchemy we use in PeerNode.shouldBeExcludedFromPeerList()
`protected NodeCrypto`	`crypto`
`protected boolean`	`disableRouting`
`protected boolean`	`disableRoutingHasBeenSetLocally`
`protected boolean`	`disableRoutingHasBeenSetRemotely`
`protected SimpleFieldSet`	`fullFieldSet`
`protected byte[]`	`hmacKey`
`protected byte[]`	`incommingKey`
`protected byte[]`	`ivKey`
`protected byte[]`	`ivNonce`
`protected long`	`jfkContextLifetime`
`protected byte[]`	`jfkKa`
`protected byte[]`	`jfkKe`
`protected byte[]`	`jfkMyRef`
`protected java.util.LinkedList<byte[]>`	`jfkNoncesSent` For FNP link setup: The initiator has to ensure that nonces send back by the responder in message2 match what was chosen in message 1
`protected boolean`	`neverConnected` True if we have never connected to this peer since it was added to this node
`protected java.util.List<Peer>`	`nominalPeer` Advertised addresses
`protected int`	`ourInitialMsgID`
`protected int`	`ourInitialSeqNum`
`protected byte[]`	`outgoingKey`
`protected long`	`peerAddedTime` When this peer was added to this node.
`java.security.interfaces.ECPublicKey`	`peerECDSAPubKey` Peer node public key; changing this means new noderef
`byte[]`	`peerECDSAPubKeyHash`
`int`	`peerNodeStatus` The status of this peer node in terms of Node.PEER_NODE_STATUS_*
`ByteCounter`	`resendByteCounter`
`static int`	`SELECTION_MAX_SAMPLES`
`static int`	`SELECTION_MIN_PEERS`
`static int`	`SELECTION_PERCENTAGE_WARNING`
`static long`	`SELECTION_SAMPLING_PERIOD`
`protected long`	`sendHandshakeTime` Time at which we should send the next handshake request
`protected boolean`	`sendingUOMLegacyExtJar` Whether we are sending the ext jar (legacy) to this peer
`protected boolean`	`sendingUOMMainJar` Whether we are sending the main jar to this peer
`boolean`	`testnetEnabled` Is this a testnet node?
`protected int`	`theirInitialMsgID`
`protected int`	`theirInitialSeqNum`
`protected boolean`	`unroutableNewerVersion` True if this peer reports that our build number is before their last-known-good build number.
`protected boolean`	`unroutableOlderVersion` True if this peer has a build number older than our last-known-good build number.

Constructor Summary

Constructors
Constructor and Description
`PeerNode(SimpleFieldSet fs, Node node2, NodeCrypto crypto, boolean fromLocal)` Create a PeerNode from a SimpleFieldSet containing a node reference for one.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`acceptedAny(boolean realTimeFlag)` Accepting a request, even if it was not GUARANTEED, resets the counters for consecutive guaranteed rejections.
`void`	`addToLocalNodeReceivedMessagesFromStatistic(Message m)`
`void`	`addToLocalNodeSentMessagesToStatistic(Message m)`
`boolean`	`allowLocalAddresses()` Is this peer allowed local addresses? If false, we will never connect to this peer via a local address even if it advertises them.
`double`	`averagePingTime()`
`double`	`averagePingTimeCorrected()` Calculated as per RFC 2988
`void`	`backoffOnResend()` Double the RTT when we resend a packet.
`protected void`	`calcNextHandshake(boolean successfulHandshakeSend, boolean dontFetchARK, boolean notRegistered)`
`int`	`calculateMaxTransfersOut(int timeout, double nonOverheadFraction)` Calculate the maximum number of outgoing transfers to this peer that we will accept in requests and inserts.
`abstract boolean`	`canAcceptAnnouncements()` Can we accept announcements from this node?
`void`	`changedIP(Peer newPeer)` IP on the other side appears to have changed...
`void`	`checkForLostPackets()`
`void`	`checkRoutableConnectionStatus()`
`boolean`	`completedAnnounce(long uid)`
`long`	`completedHandshake(long thisBootID, byte[] data, int offset, int length, BlockCipher outgoingCipher, byte[] outgoingKey, BlockCipher incommingCipher, byte[] incommingKey, Peer replyTo, boolean unverified, int negType, long trackerID, boolean isJFK4, boolean jfk4SameAsOld, byte[] hmacKey, BlockCipher ivCipher, byte[] ivNonce, int ourInitialSeqNum, int theirInitialSeqNum, int ourInitialMsgID, int theirInitialMsgID)` Called when we have completed a handshake, and have a new session key.
`void`	`couldNotSendHandshake(boolean notRegistered)` Call this method when a handshake request could not be sent (i.e.
`int`	`countFailedRevocationTransfers()`
`static PeerNode`	`create(SimpleFieldSet fs, Node node2, NodeCrypto crypto, OpennetManager opennet, PeerManager manager)` Create a DarknetPeerNode or an OpennetPeerNode as appropriate
`short`	`decrementHTL(short htl)` Decrement the HTL (or not), in accordance with our probabilistic HTL rules.
`void`	`decrementUOMSends()`
`boolean`	`disconnected(boolean dumpMessageQueue, boolean dumpTrackers)` Disconnected e.g.
`boolean`	`dontRoute()`
`void`	`dumpTracker(SessionKey brokenKey)` Only called for new format connections, for which we don't care about PacketTracker
`void`	`enterMandatoryBackoff(java.lang.String reason, boolean realTime)` When load management predicts that a peer will definitely accept the request, both before it was sent and after we got the rejected, we go into mandatory backoff.
`boolean`	`equals(java.lang.Object o)`
`SimpleFieldSet`	`exportDiskFieldSet()` (both metadata + normal fieldset but atomically)
`SimpleFieldSet`	`exportFieldSet()` Export the peer's noderef as a SimpleFieldSet
`SimpleFieldSet`	`exportMetadataFieldSet(long now)` Export metadata about the node as a SimpleFieldSet
`SimpleFieldSet`	`exportVolatileFieldSet()` Export volatile data about the node as a SimpleFieldSet
`void`	`failedRevocationTransfer()`
`abstract void`	`fatalTimeout()` After a fatal timeout - that is, a timeout that we reasonably believe originated on the node rather than downstream - we do not know whether or not the node thinks the request is still running.
`void`	`fatalTimeout(UIDTag tag, boolean offeredKey)` A fatal timeout occurred, and we don't know whether the peer is still running the request we passed in for us.
`void`	`finishedSendingUOMJar(boolean isExt)`
`void`	`forceCancelDisconnecting()` Called to cancel a delayed disconnect.
`void`	`forceDisconnect()` Force the peer to disconnect.
`protected boolean`	`fromAnonymousInitiator()`
`boolean`	`fullPacketQueued()`
`OpennetManager.ConnectionType`	`getAddedReason()`
`long`	`getBootID()` Get the current boot ID.
`long`	`getClockDelta()`
`double`	`getClosestPeerLocation(double l, java.util.Set<java.lang.Double> exclude)` Finds the closest non-excluded peer.
`SessionKey`	`getCurrentKeyTracker()`
`int`	`getDegree()` Determines the degree of the peer via the locations of its peers it provides.
`SimpleFieldSet`	`getFullNoderef()`
`int`	`getHandshakeCount()`
`Peer`	`getHandshakeIP()` Get a single address to send a handshake to.
`protected Peer[]`	`getHandshakeIPs()` Returns an array with the advertised addresses and the detected one
`int`	`getIdentityHash()` Returns a unique node identifier (usefull to compare two peernodes).
`java.lang.String`	`getIdentityString()`
`PeerNode.IncomingLoadSummaryStats`	`getIncomingLoadStats(boolean realTime)`
`protected byte[]`	`getJFKBuffer()`
`KeyAgreementSchemeContext`	`getKeyAgreementSchemeContext()`
`java.lang.String`	`getLastBackoffReason(boolean realTime)`
`java.util.Hashtable<java.lang.String,java.lang.Long>`	`getLocalNodeReceivedMessagesFromStatistic()`
`protected SimpleFieldSet`	`getLocalNoderef()` Return the relevant local node reference related to this peer's type
`java.util.Hashtable<java.lang.String,java.lang.Long>`	`getLocalNodeSentMessagesToStatistic()`
`double`	`getLocation()` Returns this peer's current keyspace location, or -1 if it is unknown.
`long`	`getLocSetTime()`
`long`	`getMainJarOfferedVersion()`
`int`	`getMaxPacketSize()`
`PeerMessageQueue`	`getMessageQueue()`
`long`	`getMessageQueueLengthBytes()`
`long`	`getNextUrgentTime(long now)`
`long`	`getOutgoingBootID()` Get the boot ID for purposes of the other node.
`OutgoingPacketMangler`	`getOutgoingMangler()` Get the OutgoingPacketMangler which encrypts outgoing packets to this node
`Peer`	`getPeer()` Get my low-level address.
`long`	`getPeerAddedTime()`
`int`	`getPeerNodeStatus()`
`protected int`	`getPeerNodeStatus(long now, long routingBackedOffUntilRT, long localRoutingBackedOffUntilBulk, boolean overPingTime, boolean noLoadStats)`
`java.lang.String`	`getPeerNodeStatusCSSClassName()`
`static java.lang.String`	`getPeerNodeStatusCSSClassName(int status)`
`java.lang.String`	`getPeerNodeStatusString()`
`static java.lang.String`	`getPeerNodeStatusString(int status)`
`double`	`getPercentTimeRoutableConnection()`
`short`	`getPollingPriorityNormal()` Priority at which the polling should run normally.
`short`	`getPollingPriorityProgress()` Priority at which the polling should run when starting, or immediately after making some progress.
`double`	`getPRejected()`
`java.lang.String`	`getPreviousBackoffReason(boolean realTime)`
`SessionKey`	`getPreviousKeyTracker()`
`long`	`getProbableSendQueueTime()` Returns the number of milliseconds that it is estimated to take to transmit the currently queued packets.
`protected byte[]`	`getPubKeyHash()`
`Peer`	`getRemoteDetectedPeer()`
`long`	`getResendBytesSent()`
`long`	`getReusableTrackerID()`
`long`	`getRoutingBackedOffUntil(boolean realTime)`
`long`	`getRoutingBackedOffUntilBulk()`
`long`	`getRoutingBackedOffUntilMax()`
`long`	`getRoutingBackedOffUntilRT()`
`long`	`getRoutingBackoffLength(boolean realTime)`
`int`	`getSimpleVersion()`
`SocketHandler`	`getSocketHandler()` Get the SocketHandler which handles incoming packets from this node
`abstract PeerNodeStatus`	`getStatus(boolean noHeavy)` Get a PeerNodeStatus for this node.
`PacketThrottle`	`getThrottle()` Get the PacketThrottle for the node's current address for the standard packet size (if the address changes then we get a new throttle).
`int`	`getThrottleWindowSize()`
`java.lang.String`	`getTMCIPeerInfo()`
`long`	`getTotalInputBytes()`
`long`	`getTotalInputSinceStartup()`
`long`	`getTotalOutputBytes()`
`long`	`getTotalOutputSinceStartup()`
`SessionKey`	`getUnverifiedKeyTracker()`
`short`	`getUptime()`
`java.lang.String`	`getVersion()`
`int`	`getVersionNumber()` Peer version, if this is supported, else -1
`java.lang.ref.WeakReference<PeerNode>`	`getWeakRef()` Get a WeakReference to this context.
`void`	`gotARK(SimpleFieldSet fs, long fetchedEdition)`
`MessageItem[]`	`grabQueuedMessageItems()` Grab all queued Message's.
`boolean`	`grabSendLoadStatsASAP(boolean realtime)`
`void`	`handleMessage(Message m)`
`boolean`	`handleReceivedPacket(byte[] buf, int offset, int length, long now, Peer replyTo)`
`int`	`handshakeSetupType()`
`boolean`	`handshakeUnknownInitiator()`
`boolean`	`hasFullNoderef()`
`int`	`hashCode()`
`boolean`	`hasLiveHandshake(long now)` Does the node have a live handshake in progress?
`protected boolean`	`ignoreLastGoodVersion()`
`void`	`incrementNumberOfSelections(long time)`
`void`	`incrementUOMSends()`
`protected boolean`	`innerCalcNextHandshake(boolean successfulHandshakeSend, boolean dontFetchARK, long now)` Set sendHandshakeTime, and return whether to fetch the ARK.
`protected boolean`	`innerProcessNewNoderef(SimpleFieldSet fs, boolean forARK, boolean forDiffNodeRef, boolean forFullNodeRef)` The synchronized part of processNewNoderef
`boolean`	`isBurstOnly()`
`boolean`	`isConnected()` Is the peer connected? Have we established the session link?
`abstract boolean`	`isDarknet()`
`boolean`	`isDisabled()` Is this peer disabled? I.e.
`boolean`	`isDisconnecting()`
`boolean`	`isFetchingARK()`
`boolean`	`isIgnoreSource()` Is this peer set to ignore source address? If so, we will always reply to the peer's official address, even if we get packets from somewhere else.
`boolean`	`isLowCapacity(boolean isRealtime)`
`boolean`	`isLowUptime()`
`abstract boolean`	`isOpennet()`
`abstract boolean`	`isOpennetForNoderef()`
`abstract boolean`	`isRealConnection()` Does this peernode want to be returned by for example PeerManager.getByPeer() ? False = seednode etc, never going to be routable.
`boolean`	`isRoutable()` Returns true if requests can be routed through this peer.
`boolean`	`isRoutingBackedOff(boolean realTime)`
`boolean`	`isRoutingBackedOff(long ignoreBackoffUnder, boolean realTime)`
`boolean`	`isRoutingBackedOffEither()`
`boolean`	`isRoutingCompatible()` Returns true if (apart from actually knowing the peer's location), it is presumed that this peer could route requests.
`abstract boolean`	`isSeed()`
`boolean`	`isSignatureVerificationSuccessfull()`
`boolean`	`isUnroutableNewerVersion()` Returns true if this (or another) peer has reported to us that our build number is too old for data to be routed to us.
`boolean`	`isUnroutableOlderVersion()` Returns true if the last-known build number for this peer is to old to allow traffic to be routed to it.
`long`	`lastReceivedAckTime()`
`long`	`lastReceivedDataPacketTime()`
`long`	`lastReceivedPacketTime()`
`long`	`lastSentPacketTime()`
`freenet.node.PeerNode.LoadSender`	`loadSender(boolean realtime)`
`void`	`localRejectedOverload(java.lang.String reason, boolean realTime)` Got a local RejectedOverload.
`MessageItem`	`makeLoadStats(boolean realtime, boolean boostPriority, boolean noRemember)` Make a load stats message.
`boolean`	`matchesIP(FreenetInetAddress addr, boolean strict)` Does this PeerNode match the given IP address?
`boolean`	`matchesPeerAndPort(Peer peer)`
`long`	`maxTimeBetweenReceivedAcks()`
`long`	`maxTimeBetweenReceivedPackets()`
`protected abstract void`	`maybeClearPeerAddedTimeOnConnect()`
`protected abstract void`	`maybeClearPeerAddedTimeOnRestart(long now)`
`void`	`maybeOnConnect()`
`void`	`maybeRekey()`
`boolean`	`maybeSendPacket(long now, boolean ackOnly)` Maybe send something.
`void`	`maybeUpdateHandshakeIPs(boolean ignoreHostnames)` Do occasional DNS requests, but ignoreHostnames should be true on PeerNode construction
`boolean`	`neverConnected()`
`boolean`	`noContactDetails()`
`boolean`	`noLongerRoutable()` Will return true if routing to this node is either explictly disabled, or disabled due to noted incompatiblity in build-version numbers.
`void`	`noLongerRoutingTo(UIDTag tag, boolean offeredKey)`
`boolean`	`notifyDisconnecting(boolean dumpMessageQueue)` Called when a delayed disconnect is occurring.
`void`	`offer(Key key)` Offer a key to this node
`protected void`	`onConnect()` A method to be called once at the beginning of every time isConnected() is true
`void`	`onFound(USK origUSK, long edition, FetchResult result)` Called when a new edition is found and downloaded.
`void`	`onNotificationOnlyPacketSent(int length)`
`void`	`onRemove()` Called when the peer is removed from the PeerManager
`void`	`onSetMaxOutputTransfers(boolean realTime, int maxOutputTransfers)`
`void`	`onSetMaxOutputTransfersPeerLimit(boolean realTime, int maxOutputTransfers)`
`void`	`onSetPeerAllocation(boolean input, int thisAllocation, int transfersPerInsert, int maxOutputTransfers, boolean realTime)`
`abstract void`	`onSuccess(boolean insert, boolean ssk)` Called when a request or insert succeeds.
`freenet.node.PeerNode.OutputLoadTracker`	`outputLoadTracker(boolean realTime)`
`java.util.Random`	`paddingGen()`
`boolean`	`ping(int pingID)` Low-level ping this node.
`void`	`postUnlock(UIDTag tag)`
`void`	`processDiffNoderef(SimpleFieldSet fs)` Process a differential node reference The identity must not change, or we throw.
`protected void`	`processNewNoderef(SimpleFieldSet fs, boolean forARK, boolean forDiffNodeRef, boolean forFullNodeRef)` Process a new nodereference, as a SimpleFieldSet.
`boolean`	`publicInvalidVersion()` The same as isUnroutableOlderVersion, but not synchronized.
`boolean`	`publicReverseInvalidVersion()` The same as inUnroutableNewerVersion.
`int`	`queueN2NM(SimpleFieldSet fs)` A method to queue an N2NM in a extra peer data file, only implemented by DarknetPeerNode.
`void`	`receivedAck(long now)` Report when a packet was acked.
`void`	`receivedPacket(boolean dontLog, boolean dataPacket)` Update timeLastReceivedPacket
`abstract boolean`	`recordStatus()`
`void`	`registerPeerNodeStatusChangeListener(PeerManager.PeerStatusChangeListener listener)` Registers a listener that will be notified when status changes.
`void`	`rejectedGuaranteed(boolean realTimeFlag)` After 5 consecutive GUARANTEED soft rejections, we enter mandatory backoff.
`void`	`reportIncomingBytes(int length)`
`void`	`reportLoadStatus(NodeStats.PeerLoadStats stat)`
`void`	`reportOutgoingBytes(int length)`
`void`	`reportPing(long t)`
`void`	`reportRoutedTo(double target, boolean isLocal, boolean realTime, PeerNode prev, java.util.Set<PeerNode> routedTo, int htl)`
`void`	`reportThrottledPacketSendTime(long timeDiff, boolean realTime)`
`void`	`resentBytes(int length)`
`void`	`resetMandatoryBackoff(boolean realTime)` Called when a request is accepted.
`double`	`selectionRate()`
`int`	`selectNegType(OutgoingPacketMangler mangler)` Select the most appropriate negType, taking the user's preference into account order matters
`MessageItem`	`sendAsync(Message msg, AsyncMessageCallback cb, ByteCounter ctr)` Send a message, off-thread, to this node.
`protected void`	`sendConnectedDiffNoderef()` A method to be called after completing a handshake to send the newly connected peer, as a differential node reference, the parts of our node reference not needed for handshake.
`void`	`sendEncryptedPacket(byte[] data)`
`boolean`	`sendingUOMJar(boolean isExt)` Start sending a UOM jar to this peer.
`protected void`	`sendInitialMessages()` Send any high level messages that need to be sent on connect.
`void`	`sendNodeToNodeMessage(SimpleFieldSet fs, int n2nType, boolean includeSentTime, long now, boolean queueOnNotConnected)`
`void`	`sendSync(Message req, ByteCounter ctr, boolean realTime)` Enqueue a message to be sent to this node and wait up to a minute for it to be transmitted and acknowledged.
`void`	`sentHandshake(boolean notRegistered)` Call this method when a handshake request has been sent.
`void`	`sentPacket()` Update timeLastSentPacket
`void`	`sentThrottledBytes(int count)`
`void`	`setAddedReason(OpennetManager.ConnectionType connectionType)`
`protected void`	`setJFKBuffer(byte[] bufferJFK)`
`void`	`setKeyAgreementSchemeContext(KeyAgreementSchemeContext ctx2)`
`void`	`setLastBackoffReason(java.lang.String s, boolean realTime)`
`void`	`setMainJarOfferedVersion(long mainJarVersion)`
`int`	`setPeerNodeStatus(long now)`
`int`	`setPeerNodeStatus(long now, boolean noLog)`
`void`	`setRemoteDetectedPeer(Peer p)`
`void`	`setSendLoadStatsASAP(boolean realtime)` Set the load stats to be sent asap.
`void`	`setTimeDelta(long delta)`
`void`	`setUptime(byte uptime2)`
`abstract boolean`	`shallWeRouteAccordingToOurPeersLocation(int htl)`
`java.lang.String`	`shortToString()` Compact toString()
`boolean`	`shouldAcceptAnnounce(long uid)`
`boolean`	`shouldBeExcludedFromPeerList()`
`boolean`	`shouldDisconnectAndRemoveNow()` Should this peer be disconnected and removed immediately?
`protected abstract boolean`	`shouldExportPeerAddedTime()`
`boolean`	`shouldPadDataPackets()`
`boolean`	`shouldRejectProbeRequest()` Should we reject a swap request?
`boolean`	`shouldRejectSwapRequest()` Should we reject a swap request?
`boolean`	`shouldSendHandshake()`
`boolean`	`shouldThrottle()`
`static boolean`	`shouldThrottle(Peer peer, Node node)`
`DecodingMessageGroup`	`startProcessingDecryptedMessages(int size)`
`void`	`startRekeying()`
`protected void`	`stopARKFetcher()`
`void`	`successNotOverload(boolean realTime)` Didn't get RejectedOverload.
`boolean`	`throttleRekey()`
`long`	`timeCheckForLostPackets()`
`long`	`timeLastConnected(long now)`
`long`	`timeLastConnectionCompleted()`
`long`	`timeLastDisconnect()`
`long`	`timeLastRoutable()`
`long`	`timeSendAcks()`
`long`	`timeSendHandshake(long now)`
`long`	`timeSinceAddedOrRestarted()`
`protected long`	`timeSinceSentUOM()`
`java.lang.String`	`toString()`
`void`	`transferFailed(java.lang.String reason, boolean realTime)` A transfer failed.
`void`	`transferSuccess(boolean realTime)` A transfer succeeded.
`boolean`	`unqueueMessage(MessageItem message)`
`void`	`updateLocation(double newLoc, double[] newLocs)`
`java.lang.String`	`userToString()`
`void`	`verified(SessionKey tracker)` Called when a packet is successfully decrypted on a given SessionKey for this node.
`void`	`wakeUpSender()`
`void`	`write(java.io.Writer w)` Write the peer's noderef to disk
`protected abstract void`	`writePeers()` Write the peers list affecting this node.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - unroutableOlderVersion
```
protected boolean unroutableOlderVersion
```
    True if this peer has a build number older than our last-known-good build number. Note that even if this is true, the node can still be 'connected'.
  - unroutableNewerVersion
```
protected boolean unroutableNewerVersion
```
    True if this peer reports that our build number is before their last-known-good build number. Note that even if this is true, the node can still be 'connected'.
  - disableRouting
```
protected boolean disableRouting
```
  - disableRoutingHasBeenSetLocally
```
protected boolean disableRoutingHasBeenSetLocally
```
  - disableRoutingHasBeenSetRemotely
```
protected boolean disableRoutingHasBeenSetRemotely
```
  - jfkKa
```
protected byte[] jfkKa
```
  - incommingKey
```
protected byte[] incommingKey
```
  - jfkKe
```
protected byte[] jfkKe
```
  - outgoingKey
```
protected byte[] outgoingKey
```
  - jfkMyRef
```
protected byte[] jfkMyRef
```
  - hmacKey
```
protected byte[] hmacKey
```
  - ivKey
```
protected byte[] ivKey
```
  - ivNonce
```
protected byte[] ivNonce
```
  - ourInitialSeqNum
```
protected int ourInitialSeqNum
```
  - theirInitialSeqNum
```
protected int theirInitialSeqNum
```
  - ourInitialMsgID
```
protected int ourInitialMsgID
```
  - theirInitialMsgID
```
protected int theirInitialMsgID
```
  - jfkContextLifetime
```
protected long jfkContextLifetime
```
  - nominalPeer
```
protected java.util.List<Peer> nominalPeer
```
    Advertised addresses
  - testnetEnabled
```
public final boolean testnetEnabled
```
    Is this a testnet node?
  - SELECTION_SAMPLING_PERIOD
```
public static final long SELECTION_SAMPLING_PERIOD
```
  - SELECTION_PERCENTAGE_WARNING
```
public static final int SELECTION_PERCENTAGE_WARNING
```
    See Also:
    
    Constant Field Values
  - SELECTION_MIN_PEERS
```
public static final int SELECTION_MIN_PEERS
```
    See Also:
    
    Constant Field Values
  - SELECTION_MAX_SAMPLES
```
public static final int SELECTION_MAX_SAMPLES
```
  - sendHandshakeTime
```
protected long sendHandshakeTime
```
    Time at which we should send the next handshake request
  - peerECDSAPubKey
```
public final java.security.interfaces.ECPublicKey peerECDSAPubKey
```
    Peer node public key; changing this means new noderef
  - peerECDSAPubKeyHash
```
public final byte[] peerECDSAPubKeyHash
```
  - peerNodeStatus
```
public int peerNodeStatus
```
    The status of this peer node in terms of Node.PEER_NODE_STATUS_*
  - neverConnected
```
protected boolean neverConnected
```
    True if we have never connected to this peer since it was added to this node
  - peerAddedTime
```
protected long peerAddedTime
```
    When this peer was added to this node. This is used differently by opennet and darknet nodes. Darknet nodes clear it after connecting but persist it across restarts, and clear it on restart unless the peer has never connected, or if it is more than 30 days ago. Opennet nodes clear it after the post-connect grace period elapses, and don't persist it across restarts.
  - crypto
```
protected final NodeCrypto crypto
```
  - BLACK_MAGIC_BACKOFF_PRUNING_TIME
```
public static final long BLACK_MAGIC_BACKOFF_PRUNING_TIME
```
    Some alchemy we use in PeerNode.shouldBeExcludedFromPeerList()
  - BLACK_MAGIC_BACKOFF_PRUNING_PERCENTAGE
```
public static final double BLACK_MAGIC_BACKOFF_PRUNING_PERCENTAGE
```
    See Also:
    
    Constant Field Values
  - jfkNoncesSent
```
protected final java.util.LinkedList<byte[]> jfkNoncesSent
```
    For FNP link setup: The initiator has to ensure that nonces send back by the responder in message2 match what was chosen in message 1
  - fullFieldSet
```
protected SimpleFieldSet fullFieldSet
```
  - backedOffPercent
```
public final RunningAverage backedOffPercent
```
  - backedOffPercentRT
```
public final RunningAverage backedOffPercentRT
```
  - backedOffPercentBulk
```
public final RunningAverage backedOffPercentBulk
```
  - resendByteCounter
```
public final ByteCounter resendByteCounter
```
  - sendingUOMMainJar
```
protected boolean sendingUOMMainJar
```
    Whether we are sending the main jar to this peer
  - sendingUOMLegacyExtJar
```
protected boolean sendingUOMLegacyExtJar
```
    Whether we are sending the ext jar (legacy) to this peer
- Constructor Detail
  - PeerNode
```
public PeerNode(SimpleFieldSet fs,
                Node node2,
                NodeCrypto crypto,
                boolean fromLocal)
         throws FSParseException,
                PeerParseException,
                ReferenceSignatureVerificationException,
                PeerTooOldException
```
    Create a PeerNode from a SimpleFieldSet containing a node reference for one. Does not add self to PeerManager.
    
    Parameters:
    
    fs - The node reference to parse.
    
    node2 - The running Node we are part of.
    
    fromLocal - True if the noderef was read from the stored peers file and can contain local metadata, and won't be signed. Otherwise, it is a new node reference from elsewhere, should not contain metadata, and will be signed.
    
    Throws:
    
    PeerTooOldException - If the peer is so old that it can no longer be parsed, e.g. because it hasn't been connected since the last major crypto change.
    
    FSParseException
    
    PeerParseException
    
    ReferenceSignatureVerificationException
- Method Detail
  - ignoreLastGoodVersion
```
protected boolean ignoreLastGoodVersion()
```
  - fromAnonymousInitiator
```
protected boolean fromAnonymousInitiator()
```
    Returns:
    
    True if the node has just connected and given us a noderef, and we did not know it beforehand. This makes it a temporary connection. At the moment this only happens on seednodes.
  - maybeClearPeerAddedTimeOnRestart
```
protected abstract void maybeClearPeerAddedTimeOnRestart(long now)
```
  - getPeer
```
public Peer getPeer()
```
    Get my low-level address. This is the address that packets have been received from from this node. Normally this is the address that packets have been received from from this node. However, if ignoreSourcePort is set, we will search for a similar address with a different port number in the node reference.
    
    Specified by:
    
    getPeer in interface PeerContext
  - getHandshakeIPs
```
protected Peer[] getHandshakeIPs()
```
    Returns an array with the advertised addresses and the detected one
  - maybeUpdateHandshakeIPs
```
public void maybeUpdateHandshakeIPs(boolean ignoreHostnames)
```
    Do occasional DNS requests, but ignoreHostnames should be true on PeerNode construction
  - getLocation
```
public double getLocation()
```
    Returns this peer's current keyspace location, or -1 if it is unknown.
  - shouldBeExcludedFromPeerList
```
public boolean shouldBeExcludedFromPeerList()
```
  - getClosestPeerLocation
```
public double getClosestPeerLocation(double l,
                                     java.util.Set<java.lang.Double> exclude)
```
    Finds the closest non-excluded peer.
    
    Parameters:
    
    exclude - the set of locations to exclude, may be null
    
    Returns:
    
    the closest non-excluded peer's location, or NaN if none is found
  - getLocSetTime
```
public long getLocSetTime()
```
  - getIdentityHash
```
public int getIdentityHash()
```
    Returns a unique node identifier (usefull to compare two peernodes).
  - isUnroutableOlderVersion
```
public boolean isUnroutableOlderVersion()
```
    Returns true if the last-known build number for this peer is to old to allow traffic to be routed to it. This does not give any indication as to the connection status of the peer.
  - isUnroutableNewerVersion
```
public boolean isUnroutableNewerVersion()
```
    Returns true if this (or another) peer has reported to us that our build number is too old for data to be routed to us. In turn, we will not route data to them either. Does not strictly indicate that the peer is connected.
  - isRoutable
```
public boolean isRoutable()
```
    Returns true if requests can be routed through this peer. True if the peer's location is known, presently connected, and routing-compatible. That is, ignoring backoff, the peer's location is known, build number is compatible, and routing has not been explicitly disabled. Note possible deadlocks! PeerManager calls this, we call PeerManager in e.g. verified.
    
    Specified by:
    
    isRoutable in interface PeerContext
  - isRoutingCompatible
```
public boolean isRoutingCompatible()
```
    Returns true if (apart from actually knowing the peer's location), it is presumed that this peer could route requests. True if this peer's build number is not 'too-old' or 'too-new', actively connected, and not marked as explicity disabled. Does not reflect any 'backoff' logic.
  - isConnected
```
public boolean isConnected()
```
    Description copied from interface: PeerContext
    
    Is the peer connected? Have we established the session link?
    
    Specified by:
    
    isConnected in interface PeerContext
  - sendAsync
```
public MessageItem sendAsync(Message msg,
                             AsyncMessageCallback cb,
                             ByteCounter ctr)
                      throws NotConnectedException
```
    Send a message, off-thread, to this node.
    
    Specified by:
    
    sendAsync in interface PeerContext
    
    Parameters:
    
    msg - The message to be sent.
    
    cb - The callback to be called when the packet has been sent, or null.
    
    ctr - A callback to tell how many bytes were used to send this message.
    
    Returns:
    
    Throws:
    
    NotConnectedException
  - wakeUpSender
```
public void wakeUpSender()
```
    Specified by:
    
    wakeUpSender in interface BasePeerNode
  - unqueueMessage
```
public boolean unqueueMessage(MessageItem message)
```
    Specified by:
    
    unqueueMessage in interface PeerContext
  - getMessageQueueLengthBytes
```
public long getMessageQueueLengthBytes()
```
  - getProbableSendQueueTime
```
public long getProbableSendQueueTime()
```
    Returns the number of milliseconds that it is estimated to take to transmit the currently queued packets.
  - lastReceivedPacketTime
```
public long lastReceivedPacketTime()
```
    Returns:
    
    The last time we received a packet.
  - lastReceivedDataPacketTime
```
public long lastReceivedDataPacketTime()
```
  - lastReceivedAckTime
```
public long lastReceivedAckTime()
```
  - timeLastConnected
```
public long timeLastConnected(long now)
```
  - timeLastRoutable
```
public long timeLastRoutable()
```
  - maybeRekey
```
public void maybeRekey()
```
    Specified by:
    
    maybeRekey in interface BasePeerNode
  - startRekeying
```
public void startRekeying()
```
    Specified by:
    
    startRekeying in interface BasePeerNode
  - getPeerAddedTime
```
public long getPeerAddedTime()
```
    Returns:
    
    The time this PeerNode was added to the node (persistent across restarts).
  - timeSinceAddedOrRestarted
```
public long timeSinceAddedOrRestarted()
```
    Returns:
    
    The time elapsed since this PeerNode was added to the node, or the node started up.
  - disconnected
```
public boolean disconnected(boolean dumpMessageQueue,
                            boolean dumpTrackers)
```
    Disconnected e.g. due to not receiving a packet for ages.
    Parameters:
    
    dumpMessageQueue - If true, clear the messages-to-send queue, and change the bootID so even if we reconnect the other side will know that a disconnect happened. If false, don't clear the messages yet. They will be cleared after an hour if the peer is disconnected at that point.
    dumpTrackers - If true, dump the SessionKey's (i.e. dump the cryptographic data so we don't understand any packets they send us).
    Possible arguments:
    
    true, true => dump everything, immediate disconnect
    
    true, false => dump messages but keep trackers so we can acknowledge messages on their end for a while.
    
    false, false => tell the rest of the node that we have disconnected but do not immediately drop messages, continue to respond to their messages.
    
    false, true => dump crypto but keep messages. DOES NOT MAKE SENSE!!! DO NOT USE!!!
    Returns:
    
    True if the node was connected, false if it was not.
  - forceDisconnect
```
public void forceDisconnect()
```
    Description copied from interface: PeerContext
    
    Force the peer to disconnect.
    
    Specified by:
    
    forceDisconnect in interface PeerContext
  - grabQueuedMessageItems
```
public MessageItem[] grabQueuedMessageItems()
```
    Grab all queued Message's.
    
    Returns:
    
    Null if no messages are queued, or an array of Message's.
  - getNextUrgentTime
```
public long getNextUrgentTime(long now)
```
    Returns:
    
    The time at which we must send a packet, even if it means it will only contains ack requests etc., or Long.MAX_VALUE if we have no pending ack request/acks/etc. Note that if this is less than now, it may not be entirely accurate i.e. we definitely must send a packet, but don't rely on it to tell you exactly how overdue we are.
  - lastSentPacketTime
```
public long lastSentPacketTime()
```
    Returns:
    
    The time at which we last sent a packet.
  - shouldSendHandshake
```
public boolean shouldSendHandshake()
```
    Returns:
    
    True, if we are disconnected and it has been a sufficient time period since we last sent a handshake attempt.
  - timeSendHandshake
```
public long timeSendHandshake(long now)
```
  - hasLiveHandshake
```
public boolean hasLiveHandshake(long now)
```
    Does the node have a live handshake in progress?
    
    Parameters:
    
    now - The current time.
  - innerCalcNextHandshake
```
protected boolean innerCalcNextHandshake(boolean successfulHandshakeSend,
                                         boolean dontFetchARK,
                                         long now)
```
    Set sendHandshakeTime, and return whether to fetch the ARK.
  - calcNextHandshake
```
protected void calcNextHandshake(boolean successfulHandshakeSend,
                                 boolean dontFetchARK,
                                 boolean notRegistered)
```
  - isBurstOnly
```
public boolean isBurstOnly()
```
  - sentHandshake
```
public void sentHandshake(boolean notRegistered)
```
    Call this method when a handshake request has been sent.
  - couldNotSendHandshake
```
public void couldNotSendHandshake(boolean notRegistered)
```
    Call this method when a handshake request could not be sent (i.e. no IP address available) sent.
  - maxTimeBetweenReceivedPackets
```
public long maxTimeBetweenReceivedPackets()
```
    Returns:
    
    The maximum time between received packets.
  - maxTimeBetweenReceivedAcks
```
public long maxTimeBetweenReceivedAcks()
```
    Returns:
    
    The maximum time between received packets.
  - ping
```
public boolean ping(int pingID)
             throws NotConnectedException
```
    Low-level ping this node.
    
    Returns:
    
    True if we received a reply inside 2000ms. (If we have heavy packet loss, it can take that long to resend).
    
    Throws:
    
    NotConnectedException
  - decrementHTL
```
public short decrementHTL(short htl)
```
    Decrement the HTL (or not), in accordance with our probabilistic HTL rules. Whether to decrement is determined once for each connection, rather than for every request, because if we don't we would get a predictable fraction of requests with each HTL - this pattern could give away a lot of information close to the originator. Although it's debatable whether it's worth worrying about given all the other information they have if close by ...
    
    Parameters:
    
    htl - The old HTL.
    
    Returns:
    
    The new HTL.
  - sendSync
```
public void sendSync(Message req,
                     ByteCounter ctr,
                     boolean realTime)
              throws NotConnectedException,
                     SyncSendWaitedTooLongException
```
    Enqueue a message to be sent to this node and wait up to a minute for it to be transmitted and acknowledged.
    
    Throws:
    
    NotConnectedException
    
    SyncSendWaitedTooLongException
  - getDegree
```
public int getDegree()
```
    Determines the degree of the peer via the locations of its peers it provides.
    
    Returns:
    
    The number of peers this peer reports having, or 0 if this peer does not provide that information.
  - updateLocation
```
public void updateLocation(double newLoc,
                           double[] newLocs)
```
  - writePeers
```
protected abstract void writePeers()
```
    Write the peers list affecting this node.
  - shouldRejectSwapRequest
```
public boolean shouldRejectSwapRequest()
```
    Should we reject a swap request?
  - shouldRejectProbeRequest
```
public boolean shouldRejectProbeRequest()
```
    Should we reject a swap request?
  - changedIP
```
public void changedIP(Peer newPeer)
```
    IP on the other side appears to have changed...
    
    Parameters:
    
    newPeer - The new address of the peer.
  - getCurrentKeyTracker
```
public SessionKey getCurrentKeyTracker()
```
    Specified by:
    
    getCurrentKeyTracker in interface BasePeerNode
    
    Returns:
    
    The current primary SessionKey, or null if we don't have one.
  - getPreviousKeyTracker
```
public SessionKey getPreviousKeyTracker()
```
    Specified by:
    
    getPreviousKeyTracker in interface BasePeerNode
    
    Returns:
    
    The previous primary SessionKey, or null if we don't have one.
  - getUnverifiedKeyTracker
```
public SessionKey getUnverifiedKeyTracker()
```
    Specified by:
    
    getUnverifiedKeyTracker in interface BasePeerNode
    
    Returns:
    
    The unverified SessionKey, if any, or null if we don't have one. The caller MUST call verified(KT) if a decrypt succeeds with this KT.
  - shortToString
```
public java.lang.String shortToString()
```
    Description copied from interface: PeerContext
    
    Compact toString()
    
    Specified by:
    
    shortToString in interface PeerContext
    
    Returns:
    
    short version of toString() *** Note that this is not synchronized! It is used by logging in code paths that will deadlock if it is synchronized! ***
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - receivedPacket
```
public void receivedPacket(boolean dontLog,
                           boolean dataPacket)
```
    Update timeLastReceivedPacket
    
    Specified by:
    
    receivedPacket in interface BasePeerNode
    
    Parameters:
    
    dontLog - If true, don't log an error or throw an exception if we are not connected. This can be used in handshaking when the connection hasn't been verified yet.
    
    dataPacket - If this is a real packet, as opposed to a handshake packet.
    
    Throws:
    
    NotConnectedException
  - receivedAck
```
public void receivedAck(long now)
```
    Description copied from interface: BasePeerNode
    
    Report when a packet was acked.
    
    Specified by:
    
    receivedAck in interface BasePeerNode
  - sentPacket
```
public void sentPacket()
```
    Update timeLastSentPacket
    
    Specified by:
    
    sentPacket in interface BasePeerNode
  - getKeyAgreementSchemeContext
```
public KeyAgreementSchemeContext getKeyAgreementSchemeContext()
```
  - setKeyAgreementSchemeContext
```
public void setKeyAgreementSchemeContext(KeyAgreementSchemeContext ctx2)
```
  - completedHandshake
```
public long completedHandshake(long thisBootID,
                               byte[] data,
                               int offset,
                               int length,
                               BlockCipher outgoingCipher,
                               byte[] outgoingKey,
                               BlockCipher incommingCipher,
                               byte[] incommingKey,
                               Peer replyTo,
                               boolean unverified,
                               int negType,
                               long trackerID,
                               boolean isJFK4,
                               boolean jfk4SameAsOld,
                               byte[] hmacKey,
                               BlockCipher ivCipher,
                               byte[] ivNonce,
                               int ourInitialSeqNum,
                               int theirInitialSeqNum,
                               int ourInitialMsgID,
                               int theirInitialMsgID)
```
    Called when we have completed a handshake, and have a new session key. Creates a new tracker and demotes the old one. Deletes the old one if the bootID isn't recognized, since if the node has restarted we cannot recover old messages. In more detail:
    - Process the new noderef (check if it's valid, pick up any new information etc).
    - Handle version conflicts (if the node is too old, or we are too old, we mark it as non-routable, but some messages will still be exchanged e.g. Update Over Mandatory stuff).
    - Deal with key trackers (if we just got message 4, the new key tracker becomes current; if we just got message 3, it's possible that our message 4 will be lost in transit, so we make the new tracker unverified. It will be promoted to current if we get a packet on it.. if the node has restarted, we dump the old key trackers, otherwise current becomes previous).
    - Complete the connection process: update the node's status, send initial messages, update the last-received-packet timestamp, etc.
    Parameters:
    
    thisBootID - The boot ID of the peer we have just connected to. This is simply a random number regenerated on every startup of the node. We use it to determine whether the node has restarted since we last saw it.
    
    data - Byte array from which to read the new noderef.
    
    offset - Offset to start reading at.
    
    length - Number of bytes to read.
    
    encKey - The new session key.
    
    replyTo - The IP the handshake came in on.
    
    trackerID - The tracker ID proposed by the other side. If -1, create a new tracker. If any other value, check whether we have it, and if we do, return that, otherwise return the ID of the new tracker.
    
    isJFK4 - If true, we are processing a JFK(4) and must respect the tracker ID chosen by the responder. If false, we are processing a JFK(3) and we can either reuse the suggested tracker ID, which the other side is able to reuse, or we can create a new tracker ID.
    
    jfk4SameAsOld - If true, the responder chose to use the tracker ID that we provided. If we don't have it now the connection fails.
    
    Returns:
    
    The ID of the new PacketTracker. If this is different to the passed-in trackerID, then it's a new tracker. -1 to indicate failure.
  - maybeClearPeerAddedTimeOnConnect
```
protected abstract void maybeClearPeerAddedTimeOnConnect()
```
  - getBootID
```
public long getBootID()
```
    Description copied from interface: PeerContext
    
    Get the current boot ID. This is a random number that changes every time the node starts up.
    
    Specified by:
    
    getBootID in interface PeerContext
  - stopARKFetcher
```
protected void stopARKFetcher()
```
  - getPollingPriorityNormal
```
public short getPollingPriorityNormal()
```
    Description copied from interface: USKRetrieverCallback
    
    Priority at which the polling should run normally. You have to return one of the constants from RequestStarter.
    
    Specified by:
    
    getPollingPriorityNormal in interface USKRetrieverCallback
  - getPollingPriorityProgress
```
public short getPollingPriorityProgress()
```
    Description copied from interface: USKRetrieverCallback
    
    Priority at which the polling should run when starting, or immediately after making some progress. You have to return one of the constants from RequestStarter.
    
    Specified by:
    
    getPollingPriorityProgress in interface USKRetrieverCallback
  - sendInitialMessages
```
protected void sendInitialMessages()
```
    Send any high level messages that need to be sent on connect.
  - verified
```
public void verified(SessionKey tracker)
```
    Called when a packet is successfully decrypted on a given SessionKey for this node. Will promote the unverifiedTracker if necessary.
    
    Specified by:
    
    verified in interface BasePeerNode
  - publicInvalidVersion
```
public boolean publicInvalidVersion()
```
    The same as isUnroutableOlderVersion, but not synchronized.
  - publicReverseInvalidVersion
```
public boolean publicReverseInvalidVersion()
```
    The same as inUnroutableNewerVersion.
  - dontRoute
```
public boolean dontRoute()
```
  - processDiffNoderef
```
public void processDiffNoderef(SimpleFieldSet fs)
                        throws FSParseException
```
    Process a differential node reference The identity must not change, or we throw.
    
    Throws:
    
    FSParseException
  - processNewNoderef
```
protected void processNewNoderef(SimpleFieldSet fs,
                                 boolean forARK,
                                 boolean forDiffNodeRef,
                                 boolean forFullNodeRef)
                          throws FSParseException
```
    Process a new nodereference, as a SimpleFieldSet.
    
    Throws:
    
    FSParseException
  - innerProcessNewNoderef
```
protected boolean innerProcessNewNoderef(SimpleFieldSet fs,
                                         boolean forARK,
                                         boolean forDiffNodeRef,
                                         boolean forFullNodeRef)
                                  throws FSParseException
```
    The synchronized part of processNewNoderef
    
    Throws:
    
    FSParseException
  - getStatus
```
public abstract PeerNodeStatus getStatus(boolean noHeavy)
```
    Get a PeerNodeStatus for this node.
    
    Parameters:
    
    noHeavy - If true, avoid any expensive operations e.g. the message count hashtables.
  - getTMCIPeerInfo
```
public java.lang.String getTMCIPeerInfo()
```
  - getVersion
```
public java.lang.String getVersion()
```
  - getSimpleVersion
```
public int getSimpleVersion()
```
  - write
```
public void write(java.io.Writer w)
           throws java.io.IOException
```
    Write the peer's noderef to disk
    
    Throws:
    
    java.io.IOException
  - exportDiskFieldSet
```
public SimpleFieldSet exportDiskFieldSet()
```
    (both metadata + normal fieldset but atomically)
  - exportMetadataFieldSet
```
public SimpleFieldSet exportMetadataFieldSet(long now)
```
    Export metadata about the node as a SimpleFieldSet
  - shouldExportPeerAddedTime
```
protected abstract boolean shouldExportPeerAddedTime()
```
  - exportVolatileFieldSet
```
public SimpleFieldSet exportVolatileFieldSet()
```
    Export volatile data about the node as a SimpleFieldSet
  - exportFieldSet
```
public SimpleFieldSet exportFieldSet()
```
    Export the peer's noderef as a SimpleFieldSet
  - isDarknet
```
public abstract boolean isDarknet()
```
    Returns:
    
    True if the node is a full darknet peer ("Friend"), which should usually be in the darknet routing table.
  - isOpennet
```
public abstract boolean isOpennet()
```
    Returns:
    
    True if the node is a full opennet peer ("Stranger"), which should usually be in the OpennetManager and opennet routing table.
  - isOpennetForNoderef
```
public abstract boolean isOpennetForNoderef()
```
    Returns:
    
    Expected value of "opennet=" in the noderef. This returns true if the node is an actual opennet peer, but also if the node is a seed client or seed server, even though they are never part of the routing table. This also determines whether we use the opennet or darknet NodeCrypto.
  - isSeed
```
public abstract boolean isSeed()
```
    Returns:
    
    True if the node is a seed client or seed server. These are never in the routing table, but their noderefs should still say opennet=true.
  - timeLastConnectionCompleted
```
public long timeLastConnectionCompleted()
```
    Returns:
    
    The time at which we last connected (or reconnected).
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - isRoutingBackedOff
```
public boolean isRoutingBackedOff(long ignoreBackoffUnder,
                                  boolean realTime)
```
  - isRoutingBackedOff
```
public boolean isRoutingBackedOff(boolean realTime)
```
  - isRoutingBackedOffEither
```
public boolean isRoutingBackedOffEither()
```
  - enterMandatoryBackoff
```
public void enterMandatoryBackoff(java.lang.String reason,
                                  boolean realTime)
```
    When load management predicts that a peer will definitely accept the request, both before it was sent and after we got the rejected, we go into mandatory backoff.
  - resetMandatoryBackoff
```
public void resetMandatoryBackoff(boolean realTime)
```
    Called when a request is accepted. We don't wait for completion, unlike successNotOverload().
  - localRejectedOverload
```
public void localRejectedOverload(java.lang.String reason,
                                  boolean realTime)
```
    Got a local RejectedOverload. Back off this node for a while.
  - successNotOverload
```
public void successNotOverload(boolean realTime)
```
    Didn't get RejectedOverload. Reset routing backoff.
  - transferFailed
```
public void transferFailed(java.lang.String reason,
                           boolean realTime)
```
    A transfer failed. Back off this node for a while.
    
    Specified by:
    
    transferFailed in interface PeerContext
  - transferSuccess
```
public void transferSuccess(boolean realTime)
```
    A transfer succeeded. Reset backoff.
  - getPRejected
```
public double getPRejected()
```
    Returns:
    
    The probability of a request sent to this peer being rejected (locally) due to overload, or timing out after being accepted.
  - averagePingTime
```
public double averagePingTime()
```
    Specified by:
    
    averagePingTime in interface BasePeerNode
  - averagePingTimeCorrected
```
public double averagePingTimeCorrected()
```
    Calculated as per RFC 2988
    
    Specified by:
    
    averagePingTimeCorrected in interface BasePeerNode
  - reportThrottledPacketSendTime
```
public void reportThrottledPacketSendTime(long timeDiff,
                                          boolean realTime)
```
    Specified by:
    
    reportThrottledPacketSendTime in interface PeerContext
  - setRemoteDetectedPeer
```
public void setRemoteDetectedPeer(Peer p)
```
  - getRemoteDetectedPeer
```
public Peer getRemoteDetectedPeer()
```
  - getRoutingBackoffLength
```
public long getRoutingBackoffLength(boolean realTime)
```
  - getRoutingBackedOffUntil
```
public long getRoutingBackedOffUntil(boolean realTime)
```
  - getRoutingBackedOffUntilMax
```
public long getRoutingBackedOffUntilMax()
```
  - getRoutingBackedOffUntilRT
```
public long getRoutingBackedOffUntilRT()
```
  - getRoutingBackedOffUntilBulk
```
public long getRoutingBackedOffUntilBulk()
```
  - getLastBackoffReason
```
public java.lang.String getLastBackoffReason(boolean realTime)
```
  - getPreviousBackoffReason
```
public java.lang.String getPreviousBackoffReason(boolean realTime)
```
  - setLastBackoffReason
```
public void setLastBackoffReason(java.lang.String s,
                                 boolean realTime)
```
  - addToLocalNodeSentMessagesToStatistic
```
public void addToLocalNodeSentMessagesToStatistic(Message m)
```
  - addToLocalNodeReceivedMessagesFromStatistic
```
public void addToLocalNodeReceivedMessagesFromStatistic(Message m)
```
  - getLocalNodeSentMessagesToStatistic
```
public java.util.Hashtable<java.lang.String,java.lang.Long> getLocalNodeSentMessagesToStatistic()
```
  - getLocalNodeReceivedMessagesFromStatistic
```
public java.util.Hashtable<java.lang.String,java.lang.Long> getLocalNodeReceivedMessagesFromStatistic()
```
  - gotARK
```
public void gotARK(SimpleFieldSet fs,
                   long fetchedEdition)
```
  - getPeerNodeStatus
```
public int getPeerNodeStatus()
```
  - getPeerNodeStatusString
```
public java.lang.String getPeerNodeStatusString()
```
  - getPeerNodeStatusString
```
public static java.lang.String getPeerNodeStatusString(int status)
```
  - getPeerNodeStatusCSSClassName
```
public java.lang.String getPeerNodeStatusCSSClassName()
```
  - getPeerNodeStatusCSSClassName
```
public static java.lang.String getPeerNodeStatusCSSClassName(int status)
```
  - getPeerNodeStatus
```
protected int getPeerNodeStatus(long now,
                                long routingBackedOffUntilRT,
                                long localRoutingBackedOffUntilBulk,
                                boolean overPingTime,
                                boolean noLoadStats)
```
  - setPeerNodeStatus
```
public int setPeerNodeStatus(long now)
```
  - setPeerNodeStatus
```
public int setPeerNodeStatus(long now,
                             boolean noLog)
```
  - recordStatus
```
public abstract boolean recordStatus()
```
  - getIdentityString
```
public java.lang.String getIdentityString()
```
  - isFetchingARK
```
public boolean isFetchingARK()
```
  - getHandshakeCount
```
public int getHandshakeCount()
```
  - noLongerRoutable
```
public boolean noLongerRoutable()
```
    Will return true if routing to this node is either explictly disabled, or disabled due to noted incompatiblity in build-version numbers. Logically: "not(isRoutable())", but will return false even if disconnected (meaning routing is not disabled).
  - maybeOnConnect
```
public void maybeOnConnect()
```
  - onConnect
```
protected void onConnect()
```
    A method to be called once at the beginning of every time isConnected() is true
  - onFound
```
public void onFound(USK origUSK,
                    long edition,
                    FetchResult result)
```
    Description copied from interface: USKRetrieverCallback
    
    Called when a new edition is found and downloaded.
    
    Specified by:
    
    onFound in interface USKRetrieverCallback
    
    edition - The USK edition number.
    
    result - The retrieved data.
  - noContactDetails
```
public boolean noContactDetails()
```
  - reportIncomingBytes
```
public void reportIncomingBytes(int length)
```
    Specified by:
    
    reportIncomingBytes in interface BasePeerNode
  - reportOutgoingBytes
```
public void reportOutgoingBytes(int length)
```
    Specified by:
    
    reportOutgoingBytes in interface BasePeerNode
  - getTotalInputBytes
```
public long getTotalInputBytes()
```
  - getTotalOutputBytes
```
public long getTotalOutputBytes()
```
  - getTotalInputSinceStartup
```
public long getTotalInputSinceStartup()
```
  - getTotalOutputSinceStartup
```
public long getTotalOutputSinceStartup()
```
  - isSignatureVerificationSuccessfull
```
public boolean isSignatureVerificationSuccessfull()
```
  - checkRoutableConnectionStatus
```
public void checkRoutableConnectionStatus()
```
  - getPercentTimeRoutableConnection
```
public double getPercentTimeRoutableConnection()
```
  - getVersionNumber
```
public int getVersionNumber()
```
    Description copied from interface: PeerContext
    
    Peer version, if this is supported, else -1
    
    Specified by:
    
    getVersionNumber in interface PeerContext
  - getThrottle
```
public PacketThrottle getThrottle()
```
    Description copied from interface: PeerContext
    
    Get the PacketThrottle for the node's current address for the standard packet size (if the address changes then we get a new throttle).
    
    Specified by:
    
    getThrottle in interface PeerContext
  - selectNegType
```
public int selectNegType(OutgoingPacketMangler mangler)
```
    Select the most appropriate negType, taking the user's preference into account order matters
    
    Parameters:
    
    mangler -
    
    Returns:
    
    -1 if no common negType has been found
  - userToString
```
public java.lang.String userToString()
```
  - setTimeDelta
```
public void setTimeDelta(long delta)
```
  - getClockDelta
```
public long getClockDelta()
```
  - offer
```
public void offer(Key key)
```
    Offer a key to this node
  - getOutgoingMangler
```
public OutgoingPacketMangler getOutgoingMangler()
```
    Description copied from interface: PeerContext
    
    Get the OutgoingPacketMangler which encrypts outgoing packets to this node
    
    Specified by:
    
    getOutgoingMangler in interface PeerContext
  - getSocketHandler
```
public SocketHandler getSocketHandler()
```
    Description copied from interface: PeerContext
    
    Get the SocketHandler which handles incoming packets from this node
    
    Specified by:
    
    getSocketHandler in interface PeerContext
  - isDisabled
```
public boolean isDisabled()
```
    Is this peer disabled? I.e. has the user explicitly disabled it?
  - allowLocalAddresses
```
public boolean allowLocalAddresses()
```
    Is this peer allowed local addresses? If false, we will never connect to this peer via a local address even if it advertises them.
  - isIgnoreSource
```
public boolean isIgnoreSource()
```
    Is this peer set to ignore source address? If so, we will always reply to the peer's official address, even if we get packets from somewhere else. @see DarknetPeerNode.isIgnoreSourcePort().
  - create
```
public static PeerNode create(SimpleFieldSet fs,
                              Node node2,
                              NodeCrypto crypto,
                              OpennetManager opennet,
                              PeerManager manager)
                       throws FSParseException,
                              PeerParseException,
                              ReferenceSignatureVerificationException,
                              PeerTooOldException
```
    Create a DarknetPeerNode or an OpennetPeerNode as appropriate
    
    Throws:
    
    PeerTooOldException
    
    FSParseException
    
    PeerParseException
    
    ReferenceSignatureVerificationException
  - neverConnected
```
public boolean neverConnected()
```
  - onSuccess
```
public abstract void onSuccess(boolean insert,
                               boolean ssk)
```
    Called when a request or insert succeeds. Used by opennet.
  - notifyDisconnecting
```
public boolean notifyDisconnecting(boolean dumpMessageQueue)
```
    Called when a delayed disconnect is occurring. Tell the node that it is being disconnected, but that the process may take a while. After this point, requests will not be accepted from the peer nor routed to it.
    
    Parameters:
    
    dumpMessageQueue - If true, immediately dump the message queue, since we are closing the connection due to some low level trouble e.g. not acknowledging. We will continue to try to send anything already in flight, and it is possible to send more messages after this point, for instance the message telling it we are disconnecting, but see above - no requests will be routed across this connection.
    
    Returns:
    
    True if we have already started disconnecting, false otherwise.
  - forceCancelDisconnecting
```
public void forceCancelDisconnecting()
```
    Called to cancel a delayed disconnect. Always succeeds even if the node was not being disconnected.
  - onRemove
```
public void onRemove()
```
    Called when the peer is removed from the PeerManager
  - isDisconnecting
```
public boolean isDisconnecting()
```
  - getJFKBuffer
```
protected byte[] getJFKBuffer()
```
  - setJFKBuffer
```
protected void setJFKBuffer(byte[] bufferJFK)
```
  - shouldAcceptAnnounce
```
public boolean shouldAcceptAnnounce(long uid)
```
  - completedAnnounce
```
public boolean completedAnnounce(long uid)
```
  - timeLastDisconnect
```
public long timeLastDisconnect()
```
  - isRealConnection
```
public abstract boolean isRealConnection()
```
    Does this peernode want to be returned by for example PeerManager.getByPeer() ? False = seednode etc, never going to be routable.
  - canAcceptAnnouncements
```
public abstract boolean canAcceptAnnouncements()
```
    Can we accept announcements from this node?
  - handshakeUnknownInitiator
```
public boolean handshakeUnknownInitiator()
```
  - handshakeSetupType
```
public int handshakeSetupType()
```
  - getWeakRef
```
public java.lang.ref.WeakReference<PeerNode> getWeakRef()
```
    Description copied from interface: PeerContext
    
    Get a WeakReference to this context. Hopefully there is only one of these for the whole object; they are quite expensive.
    
    Specified by:
    
    getWeakRef in interface PeerContext
  - getHandshakeIP
```
public Peer getHandshakeIP()
```
    Get a single address to send a handshake to. The current code doesn't work well with multiple simulataneous handshakes. Alternates between valid values. (FIXME!)
  - sendNodeToNodeMessage
```
public void sendNodeToNodeMessage(SimpleFieldSet fs,
                                  int n2nType,
                                  boolean includeSentTime,
                                  long now,
                                  boolean queueOnNotConnected)
```
  - queueN2NM
```
public int queueN2NM(SimpleFieldSet fs)
```
    A method to queue an N2NM in a extra peer data file, only implemented by DarknetPeerNode. Returns the fileNumber of the created n2nm, -1 if no file was created.
  - getLocalNoderef
```
protected SimpleFieldSet getLocalNoderef()
```
    Return the relevant local node reference related to this peer's type
  - sendConnectedDiffNoderef
```
protected void sendConnectedDiffNoderef()
```
    A method to be called after completing a handshake to send the newly connected peer, as a differential node reference, the parts of our node reference not needed for handshake. Should only be called by completedHandshake() after we're happy with the connection FIXME this should be sent when our noderef changes.
  - shouldThrottle
```
public boolean shouldThrottle()
```
    Specified by:
    
    shouldThrottle in interface BasePeerNode
  - shouldThrottle
```
public static boolean shouldThrottle(Peer peer,
                                     Node node)
```
  - reportPing
```
public void reportPing(long t)
```
    Specified by:
    
    reportPing in interface BasePeerNode
  - backoffOnResend
```
public void backoffOnResend()
```
    Description copied from interface: BasePeerNode
    
    Double the RTT when we resend a packet.
    
    Specified by:
    
    backoffOnResend in interface BasePeerNode
  - getResendBytesSent
```
public long getResendBytesSent()
```
  - shouldDisconnectAndRemoveNow
```
public boolean shouldDisconnectAndRemoveNow()
```
    Should this peer be disconnected and removed immediately?
  - setUptime
```
public void setUptime(byte uptime2)
```
  - getUptime
```
public short getUptime()
```
  - incrementNumberOfSelections
```
public void incrementNumberOfSelections(long time)
```
  - selectionRate
```
public double selectionRate()
```
    Returns:
    
    The rate at which this peer has been selected since it connected.
  - setMainJarOfferedVersion
```
public void setMainJarOfferedVersion(long mainJarVersion)
```
  - getMainJarOfferedVersion
```
public long getMainJarOfferedVersion()
```
  - maybeSendPacket
```
public boolean maybeSendPacket(long now,
                               boolean ackOnly)
                        throws BlockedTooLongException
```
    Maybe send something. A SINGLE PACKET. Don't send everything at once, for two reasons: 1. It is possible for a node to have a very long backlog. 2. Sometimes sending a packet can take a long time. 3. In the near future PacketSender will be responsible for output bandwidth throttling. So it makes sense to send a single packet and round-robin.
    
    Parameters:
    
    now -
    
    ackOnly -
    
    Throws:
    
    BlockedTooLongException
  - getReusableTrackerID
```
public long getReusableTrackerID()
```
    Returns:
    
    The ID of a reusable PacketTracker if there is one, otherwise -1.
  - failedRevocationTransfer
```
public void failedRevocationTransfer()
```
  - countFailedRevocationTransfers
```
public int countFailedRevocationTransfers()
```
  - registerPeerNodeStatusChangeListener
```
public void registerPeerNodeStatusChangeListener(PeerManager.PeerStatusChangeListener listener)
```
    Registers a listener that will be notified when status changes. Only the WeakReference of it is stored, so there is no need for deregistering
    
    Parameters:
    
    listener - - The listener to be registered
  - isLowUptime
```
public boolean isLowUptime()
```
  - setAddedReason
```
public void setAddedReason(OpennetManager.ConnectionType connectionType)
```
  - getAddedReason
```
public OpennetManager.ConnectionType getAddedReason()
```
  - onSetMaxOutputTransfers
```
public void onSetMaxOutputTransfers(boolean realTime,
                                    int maxOutputTransfers)
```
  - onSetMaxOutputTransfersPeerLimit
```
public void onSetMaxOutputTransfersPeerLimit(boolean realTime,
                                             int maxOutputTransfers)
```
  - onSetPeerAllocation
```
public void onSetPeerAllocation(boolean input,
                                int thisAllocation,
                                int transfersPerInsert,
                                int maxOutputTransfers,
                                boolean realTime)
```
  - outputLoadTracker
```
public freenet.node.PeerNode.OutputLoadTracker outputLoadTracker(boolean realTime)
```
  - reportLoadStatus
```
public void reportLoadStatus(NodeStats.PeerLoadStats stat)
```
  - noLongerRoutingTo
```
public void noLongerRoutingTo(UIDTag tag,
                              boolean offeredKey)
```
  - postUnlock
```
public void postUnlock(UIDTag tag)
```
  - getIncomingLoadStats
```
public PeerNode.IncomingLoadSummaryStats getIncomingLoadStats(boolean realTime)
```
  - loadSender
```
public freenet.node.PeerNode.LoadSender loadSender(boolean realtime)
```
  - fatalTimeout
```
public void fatalTimeout(UIDTag tag,
                         boolean offeredKey)
```
    A fatal timeout occurred, and we don't know whether the peer is still running the request we passed in for us. If it is, we cannot reuse that slot. So we need to query it periodically until it is no longer running it. If we cannot send the query or if we don't get a response, we disconnect via fatalTimeout() (with no arguments).
    
    Parameters:
    
    tag - The request which we routed to this peer. It may or may not still be running.
  - fatalTimeout
```
public abstract void fatalTimeout()
```
    After a fatal timeout - that is, a timeout that we reasonably believe originated on the node rather than downstream - we do not know whether or not the node thinks the request is still running. Hence load management will get really confused and likely start to send requests over and over, which are repeatedly rejected. So we have some alternatives: 1) Lock the slot forever (or at least until the node reconnects). So every time a node times out, it loses a slot, and gradually it becomes completely catatonic. 2) Wait forever for an acknowledgement of the timeout. This may be worth investigating. One problem with this is that the slot would still count towards our overall load management, which is surely a bad thing, although we could make it only count towards this node. Also, if it doesn't arrive in a reasonable time maybe there has been a severe problem e.g. out of memory, bug etc; in that case, waiting forever may not be sensible. 3) Disconnect the node. This makes perfect sense for opennet. For darknet it's a bit more problematic. 4) Turn off routing to the node, possibly for a limited period. This would need to include the effects of disconnection. It might open up some cheapish local DoS's. For all nodes, at present, we disconnect. For darknet nodes, we log an error, and allow them to reconnect.
  - shallWeRouteAccordingToOurPeersLocation
```
public abstract boolean shallWeRouteAccordingToOurPeersLocation(int htl)
```
  - getMessageQueue
```
public PeerMessageQueue getMessageQueue()
```
    Specified by:
    
    getMessageQueue in interface BasePeerNode
  - handleReceivedPacket
```
public boolean handleReceivedPacket(byte[] buf,
                                    int offset,
                                    int length,
                                    long now,
                                    Peer replyTo)
```
  - checkForLostPackets
```
public void checkForLostPackets()
```
  - timeCheckForLostPackets
```
public long timeCheckForLostPackets()
```
  - dumpTracker
```
public void dumpTracker(SessionKey brokenKey)
```
    Only called for new format connections, for which we don't care about PacketTracker
  - handleMessage
```
public void handleMessage(Message m)
```
    Specified by:
    
    handleMessage in interface BasePeerNode
  - sendEncryptedPacket
```
public void sendEncryptedPacket(byte[] data)
                         throws Peer.LocalAddressException
```
    Specified by:
    
    sendEncryptedPacket in interface BasePeerNode
    
    Throws:
    
    Peer.LocalAddressException
  - getMaxPacketSize
```
public int getMaxPacketSize()
```
    Specified by:
    
    getMaxPacketSize in interface BasePeerNode
  - shouldPadDataPackets
```
public boolean shouldPadDataPackets()
```
    Specified by:
    
    shouldPadDataPackets in interface BasePeerNode
  - sentThrottledBytes
```
public void sentThrottledBytes(int count)
```
    Specified by:
    
    sentThrottledBytes in interface BasePeerNode
  - onNotificationOnlyPacketSent
```
public void onNotificationOnlyPacketSent(int length)
```
    Specified by:
    
    onNotificationOnlyPacketSent in interface BasePeerNode
  - resentBytes
```
public void resentBytes(int length)
```
    Specified by:
    
    resentBytes in interface BasePeerNode
  - paddingGen
```
public java.util.Random paddingGen()
```
    Specified by:
    
    paddingGen in interface BasePeerNode
  - matchesPeerAndPort
```
public boolean matchesPeerAndPort(Peer peer)
```
  - matchesIP
```
public boolean matchesIP(FreenetInetAddress addr,
                         boolean strict)
```
    Does this PeerNode match the given IP address?
    
    Parameters:
    
    strict - If true, only match if the IP is actually in use. If false, also match from nominal IP addresses and domain names etc.
  - makeLoadStats
```
public MessageItem makeLoadStats(boolean realtime,
                                 boolean boostPriority,
                                 boolean noRemember)
```
    Description copied from interface: BasePeerNode
    
    Make a load stats message.
    
    Specified by:
    
    makeLoadStats in interface BasePeerNode
    
    Parameters:
    
    realtime - True for the realtime load stats, false for the bulk load stats.
    
    boostPriority - If true, boost the priority so it gets sent fast.
    
    noRemember - If true, generating it for a lossy message in a packet; don't remember that we sent it, since it might be lost, and generate it even if the last one was the same, since the last one might be delayed.
  - grabSendLoadStatsASAP
```
public boolean grabSendLoadStatsASAP(boolean realtime)
```
    Specified by:
    
    grabSendLoadStatsASAP in interface BasePeerNode
  - setSendLoadStatsASAP
```
public void setSendLoadStatsASAP(boolean realtime)
```
    Description copied from interface: BasePeerNode
    
    Set the load stats to be sent asap. E.g. if we grabbed it and can't actually execute the send for some reason.
    
    Specified by:
    
    setSendLoadStatsASAP in interface BasePeerNode
  - startProcessingDecryptedMessages
```
public DecodingMessageGroup startProcessingDecryptedMessages(int size)
```
    Specified by:
    
    startProcessingDecryptedMessages in interface BasePeerNode
  - isLowCapacity
```
public boolean isLowCapacity(boolean isRealtime)
```
  - reportRoutedTo
```
public void reportRoutedTo(double target,
                           boolean isLocal,
                           boolean realTime,
                           PeerNode prev,
                           java.util.Set<PeerNode> routedTo,
                           int htl)
```
  - sendingUOMJar
```
public boolean sendingUOMJar(boolean isExt)
```
    Start sending a UOM jar to this peer.
    
    Returns:
    
    True unless it was already sending, in which case the caller should reject it.
  - finishedSendingUOMJar
```
public void finishedSendingUOMJar(boolean isExt)
```
  - timeSinceSentUOM
```
protected long timeSinceSentUOM()
```
  - incrementUOMSends
```
public void incrementUOMSends()
```
  - decrementUOMSends
```
public void decrementUOMSends()
```
  - getOutgoingBootID
```
public long getOutgoingBootID()
```
    Get the boot ID for purposes of the other node. This is set to a random number on startup, but also whenever we disconnected(true,...) i.e. whenever we dump the message queues and PacketFormat's.
  - throttleRekey
```
public boolean throttleRekey()
```
  - fullPacketQueued
```
public boolean fullPacketQueued()
```
  - timeSendAcks
```
public long timeSendAcks()
```
  - calculateMaxTransfersOut
```
public int calculateMaxTransfersOut(int timeout,
                                    double nonOverheadFraction)
```
    Calculate the maximum number of outgoing transfers to this peer that we will accept in requests and inserts.
  - hasFullNoderef
```
public boolean hasFullNoderef()
```
  - getFullNoderef
```
public SimpleFieldSet getFullNoderef()
```
  - rejectedGuaranteed
```
public void rejectedGuaranteed(boolean realTimeFlag)
```
    After 5 consecutive GUARANTEED soft rejections, we enter mandatory backoff. The reason why we don't immediately enter mandatory backoff is as follows: PROBLEM: Requests could have completed between the time when the request was rejected and now. SOLUTION A: Tracking all possible requests which completed since the request was sent. CON: This would be rather complex, and I'm not sure how well it would work when there are many requests in flight; would it even be possible without stopping sending requests after some arbitrary threshold? We might need a time element, and would probably need parameters... SOLUTION B: Enforcing a hard peer limit on both sides, as opposed to accepting a request if the *current* usage, without the new request, is over the limit. CON: This would break fairness between request types. Of course, the problem with just using a counter is it may need to be changed frequently ... FIXME create a better solution! Fortunately, this is pretty rare. It happens when e.g. we send an SSK, then we send a CHK, the messages are reordered and the CHK is accepted, and then the SSK is rejected. Both were GUARANTEED because if they are accepted in order, thanks to the mechanism referred to in solution B, they will both be accepted.
  - acceptedAny
```
public void acceptedAny(boolean realTimeFlag)
```
    Accepting a request, even if it was not GUARANTEED, resets the counters for consecutive guaranteed rejections. @see rejectedGuaranteed(boolean realTimeFlag).
  - getThrottleWindowSize
```
public int getThrottleWindowSize()
```
    Specified by:
    
    getThrottleWindowSize in interface PeerContext
    
    Returns:
    
    The largest throttle window size of any of our throttles. This is just for guesstimating how many blocks we can have in flight.
  - getPubKeyHash
```
protected final byte[] getPubKeyHash()
```

Class PeerNode

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

unroutableOlderVersion

unroutableNewerVersion

disableRouting

disableRoutingHasBeenSetLocally

disableRoutingHasBeenSetRemotely

jfkKa

incommingKey

jfkKe

outgoingKey

jfkMyRef

hmacKey

ivKey

ivNonce

ourInitialSeqNum

theirInitialSeqNum

ourInitialMsgID

theirInitialMsgID

jfkContextLifetime

nominalPeer

testnetEnabled

SELECTION_SAMPLING_PERIOD

SELECTION_PERCENTAGE_WARNING

SELECTION_MIN_PEERS

SELECTION_MAX_SAMPLES

sendHandshakeTime

peerECDSAPubKey

peerECDSAPubKeyHash

peerNodeStatus

neverConnected

peerAddedTime

crypto

BLACK_MAGIC_BACKOFF_PRUNING_TIME

BLACK_MAGIC_BACKOFF_PRUNING_PERCENTAGE

jfkNoncesSent

fullFieldSet

backedOffPercent

backedOffPercentRT

backedOffPercentBulk

resendByteCounter

sendingUOMMainJar

sendingUOMLegacyExtJar

Constructor Detail

PeerNode

Method Detail

ignoreLastGoodVersion

fromAnonymousInitiator

maybeClearPeerAddedTimeOnRestart

getPeer

getHandshakeIPs

maybeUpdateHandshakeIPs

getLocation

shouldBeExcludedFromPeerList

getClosestPeerLocation

getLocSetTime

getIdentityHash

isUnroutableOlderVersion

isUnroutableNewerVersion

isRoutable

isRoutingCompatible

isConnected

sendAsync

wakeUpSender

unqueueMessage

getMessageQueueLengthBytes

getProbableSendQueueTime

lastReceivedPacketTime

lastReceivedDataPacketTime

lastReceivedAckTime

timeLastConnected

timeLastRoutable

maybeRekey

startRekeying

getPeerAddedTime