BlockReceiver (fred API)

java.lang.Object
- freenet.io.xfer.BlockReceiver

All Implemented Interfaces:

AsyncMessageFilterCallback
```
public class BlockReceiver
extends java.lang.Object
implements AsyncMessageFilterCallback
```
IMPORTANT: The receiver can cancel the incoming transfer. This may or may not, depending on the caller, result in the PRB being cancelled, and thus propagate back to the originator. This allows for a weak DoS, in that a node can start a request and then cancel it, having wasted a certain amount of upstream bandwidth on transferring data, especially if upstream has lots of bandwidth and the attacker has limited bandwidth in the victim -> attacker direction. However this behaviour can be detected fairly easily. If we allow receiver cancels and don't propagate, a more serious DoS is possible. If we don't allow receiver cancels, we have to get rid of turtles, and massively tighten up transfer timeouts. However, if we do that, we have to consider that a node might be able to connect, max out the bandwidth with transfers, and then disconnect, avoiding the need to spend bandwidth on receiving all the data; and then reconnect, after it's confident that the transfers to it will have been cancelled. Or not reconnect at all, on opennet - just use a different identity. Downstream bandwidth is very cheap for small-scale attackers, but if this is a usable force multiplier it could still be a good DoS if we went that way. But if we did get rid of receiver cancels, it *would* mean we could get rid of a lot of code - e.g. the ReceiverAbortHandler, which in some cases (e.g RequestHandler) is complex and involves complex security tradeoffs. It would also make transfers significantly more reliable.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface BlockReceiver.BlockReceiverCompletion

static interface BlockReceiver.BlockReceiverTimeoutHandler

Nested Classes
Modifier and Type	Class and Description
`static interface`	`BlockReceiver.BlockReceiverCompletion`
`static interface`	`BlockReceiver.BlockReceiverTimeoutHandler`

Field Summary

Fields
Modifier and Type	Field and Description
`static long`	`ACK_TRANSFER_FAILED_TIMEOUT` sendAborted is not sent at the realtime/bulk priority.
`static long`	`CLEANUP_TIMEOUT`
`static int`	`MAX_CONSECUTIVE_MISSING_PACKET_REPORTS`
`long`	`MAX_ROUND_TRIP_TIME`
`static int`	`MAX_SEND_INTERVAL`
`long`	`RECEIPT_TIMEOUT`
`static long`	`RECEIPT_TIMEOUT_BULK`
`static long`	`RECEIPT_TIMEOUT_REALTIME`
`static long`	`TOO_LONG_TIMEOUT`

Constructor Summary

Constructors
Constructor and Description
`BlockReceiver(MessageCore usm, PeerContext sender, long uid, PartiallyReceivedBlock prb, ByteCounter ctr, Ticker ticker, boolean doTooLong, boolean realTime, BlockReceiver.BlockReceiverTimeoutHandler timeoutHandler, boolean completeAfterAckedAllReceived)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`getRunningReceives()`
`void`	`onDisconnect(PeerContext ctx)` Called when the filter is dropped because a connection is dropped.
`void`	`onMatched(Message m)` Used to discard leftover messages, usually just packetTransmit and allSent.
`void`	`onRestarted(PeerContext ctx)` Called when the filter is dropped because a connection is restarted.
`void`	`onTimeout()` Called when the filter times out and is removed from the list of filters to match.
`void`	`receive(BlockReceiver.BlockReceiverCompletion callback)`
`boolean`	`senderAborted()`
`boolean`	`shouldTimeout()` Check whether the filter should be removed.
`java.lang.String`	`toString()`

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

- Field Detail
  - RECEIPT_TIMEOUT
```
public final long RECEIPT_TIMEOUT
```
  - RECEIPT_TIMEOUT_REALTIME
```
public static final long RECEIPT_TIMEOUT_REALTIME
```
  - RECEIPT_TIMEOUT_BULK
```
public static final long RECEIPT_TIMEOUT_BULK
```
  - MAX_ROUND_TRIP_TIME
```
public final long MAX_ROUND_TRIP_TIME
```
  - MAX_CONSECUTIVE_MISSING_PACKET_REPORTS
```
public static final int MAX_CONSECUTIVE_MISSING_PACKET_REPORTS
```
    See Also:
    
    Constant Field Values
  - MAX_SEND_INTERVAL
```
public static final int MAX_SEND_INTERVAL
```
    See Also:
    
    Constant Field Values
  - CLEANUP_TIMEOUT
```
public static final long CLEANUP_TIMEOUT
```
  - TOO_LONG_TIMEOUT
```
public static final long TOO_LONG_TIMEOUT
```
  - ACK_TRANSFER_FAILED_TIMEOUT
```
public static final long ACK_TRANSFER_FAILED_TIMEOUT
```
    sendAborted is not sent at the realtime/bulk priority. Most of the two stage timeout stuff uses 60 seconds, it's a good number.
- Constructor Detail
  - BlockReceiver
```
public BlockReceiver(MessageCore usm,
                     PeerContext sender,
                     long uid,
                     PartiallyReceivedBlock prb,
                     ByteCounter ctr,
                     Ticker ticker,
                     boolean doTooLong,
                     boolean realTime,
                     BlockReceiver.BlockReceiverTimeoutHandler timeoutHandler,
                     boolean completeAfterAckedAllReceived)
```
    Parameters:
    
    usm -
    
    sender -
    
    uid -
    
    prb -
    
    ctr -
    
    ticker -
    
    doTooLong -
    
    realTime -
    
    timeoutHandler -
    
    completeAfterAckedAllReceived - If true, we need to call completion only after we have received an ack to the allReceived message. Generally, handlers want to complete early (=false), so the slot is freed up and can be reused by the other side; senders want to complete late, so they don't end up reusing the slot before the handler has completed (=true).
- Method Detail
  - receive
```
public void receive(BlockReceiver.BlockReceiverCompletion callback)
```
  - onMatched
```
public void onMatched(Message m)
```
    Used to discard leftover messages, usually just packetTransmit and allSent. allSent, is quite common, as the receive() routine usually quits immeadiately on receiving all packets. packetTransmit is less common, when receive() requested what it thought was a missing packet, only reordered.
    
    Specified by:
    
    onMatched in interface AsyncMessageFilterCallback
    
    Parameters:
    
    m - The message which matched the filter.
  - shouldTimeout
```
public boolean shouldTimeout()
```
    Description copied from interface: AsyncMessageFilterCallback
    
    Check whether the filter should be removed. Note that USM locks may be held by the caller when this is called: the implementation should not do anything that might cause USM-related locks to be taken or messages to be sent.
    
    Specified by:
    
    shouldTimeout in interface AsyncMessageFilterCallback
    
    Returns:
    
    True if the filter should be immediately timed out.
  - onTimeout
```
public void onTimeout()
```
    Description copied from interface: AsyncMessageFilterCallback
    
    Called when the filter times out and is removed from the list of filters to match.
    
    Specified by:
    
    onTimeout in interface AsyncMessageFilterCallback
  - onDisconnect
```
public void onDisconnect(PeerContext ctx)
```
    Description copied from interface: AsyncMessageFilterCallback
    
    Called when the filter is dropped because a connection is dropped.
    
    Specified by:
    
    onDisconnect in interface AsyncMessageFilterCallback
  - onRestarted
```
public void onRestarted(PeerContext ctx)
```
    Description copied from interface: AsyncMessageFilterCallback
    
    Called when the filter is dropped because a connection is restarted.
    
    Specified by:
    
    onRestarted in interface AsyncMessageFilterCallback
  - senderAborted
```
public boolean senderAborted()
```
  - getRunningReceives
```
public static int getRunningReceives()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class BlockReceiver

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

RECEIPT_TIMEOUT

RECEIPT_TIMEOUT_REALTIME

RECEIPT_TIMEOUT_BULK

MAX_ROUND_TRIP_TIME

MAX_CONSECUTIVE_MISSING_PACKET_REPORTS

MAX_SEND_INTERVAL

CLEANUP_TIMEOUT

TOO_LONG_TIMEOUT

ACK_TRANSFER_FAILED_TIMEOUT

Constructor Detail

BlockReceiver

Method Detail

receive

onMatched

shouldTimeout

onTimeout

onDisconnect

onRestarted

senderAborted

getRunningReceives

toString