Author: toad
Date: 2008-12-16 23:43:16 +0000 (Tue, 16 Dec 2008)
New Revision: 24396
Modified:
trunk/freenet/src/freenet/node/FNPPacketMangler.java
trunk/freenet/src/freenet/node/OutgoingPacketMangler.java
trunk/freenet/src/freenet/node/PacketTracker.java
trunk/freenet/src/freenet/node/PeerNode.java
Log:
Rename KeyTracker to SessionKey
Modified: trunk/freenet/src/freenet/node/FNPPacketMangler.java
===================================================================
--- trunk/freenet/src/freenet/node/FNPPacketMangler.java 2008-12-16
23:35:49 UTC (rev 24395)
+++ trunk/freenet/src/freenet/node/FNPPacketMangler.java 2008-12-16
23:43:16 UTC (rev 24396)
@@ -1803,7 +1803,7 @@
* We need to know where the packet has come from in order to
* decrypt and authenticate it.
*/
- private boolean tryProcess(byte[] buf, int offset, int length,
KeyTracker tracker, long now) {
+ private boolean tryProcess(byte[] buf, int offset, int length,
SessionKey tracker, long now) {
// Need to be able to call with tracker == null to simplify
code above
if(tracker == null) {
if(Logger.shouldLog(Logger.DEBUG, this))
Logger.debug(this, "Tracker == null");
@@ -1917,9 +1917,9 @@
* Process an incoming packet, once it has been decrypted.
* @param decrypted The packet's contents.
* @param seqNumber The detected sequence number of the packet.
- * @param tracker The KeyTracker responsible for the key used to
encrypt the packet.
+ * @param tracker The SessionKey responsible for the key used to
encrypt the packet.
*/
- private void processDecryptedData(byte[] decrypted, int seqNumber,
KeyTracker tracker, int overhead) {
+ private void processDecryptedData(byte[] decrypted, int seqNumber,
SessionKey tracker, int overhead) {
/**
* Decoded format:
* 1 byte - version number (0)
@@ -2105,7 +2105,7 @@
if(logMINOR) Logger.minor(this, "processOutgoingOrRequeue
"+messages.length+" messages for "+pn);
byte[][] messageData = new byte[messages.length][];
MessageItem[] newMsgs = new MessageItem[messages.length];
- KeyTracker kt = pn.getCurrentKeyTracker();
+ SessionKey kt = pn.getCurrentKeyTracker();
if(kt == null) {
Logger.error(this, "Not connected while sending
packets: "+pn);
if(!dontRequeue) {
@@ -2342,9 +2342,9 @@
}
/* (non-Javadoc)
- * @see freenet.node.OutgoingPacketMangler#processOutgoing(byte[], int,
int, freenet.node.KeyTracker, int)
+ * @see freenet.node.OutgoingPacketMangler#processOutgoing(byte[], int,
int, freenet.node.SessionKey, int)
*/
- public int processOutgoing(byte[] buf, int offset, int length,
KeyTracker tracker, short priority) throws KeyChangedException,
NotConnectedException, PacketSequenceException, WouldBlockException {
+ public int processOutgoing(byte[] buf, int offset, int length,
SessionKey tracker, short priority) throws KeyChangedException,
NotConnectedException, PacketSequenceException, WouldBlockException {
byte[] newBuf = preformat(buf, offset, length);
return processOutgoingPreformatted(newBuf, 0, newBuf.length,
tracker, -1, null, priority);
}
@@ -2355,12 +2355,12 @@
* @throws PacketSequenceException
*/
int processOutgoingPreformatted(byte[] buf, int offset, int length,
PeerNode peer, AsyncMessageCallback[] callbacks, short priority) throws
NotConnectedException, WouldBlockException, PacketSequenceException {
- KeyTracker last = null;
+ SessionKey last = null;
while(true) {
try {
if(!peer.isConnected())
throw new NotConnectedException();
- KeyTracker tracker =
peer.getCurrentKeyTracker();
+ SessionKey tracker =
peer.getCurrentKeyTracker();
last = tracker;
if(tracker == null) {
Logger.normal(this, "Dropping packet:
Not connected to "+peer.getPeer()+" yet(2)");
@@ -2398,9 +2398,9 @@
}
/* (non-Javadoc)
- * @see
freenet.node.OutgoingPacketMangler#processOutgoingPreformatted(byte[], int,
int, freenet.node.KeyTracker, int, freenet.node.AsyncMessageCallback[], int)
+ * @see
freenet.node.OutgoingPacketMangler#processOutgoingPreformatted(byte[], int,
int, freenet.node.SessionKey, int, freenet.node.AsyncMessageCallback[], int)
*/
- public int processOutgoingPreformatted(byte[] buf, int offset, int
length, KeyTracker tracker, int packetNumber, AsyncMessageCallback[] callbacks,
short priority) throws KeyChangedException, NotConnectedException,
PacketSequenceException, WouldBlockException {
+ public int processOutgoingPreformatted(byte[] buf, int offset, int
length, SessionKey tracker, int packetNumber, AsyncMessageCallback[] callbacks,
short priority) throws KeyChangedException, NotConnectedException,
PacketSequenceException, WouldBlockException {
if(logMINOR) {
String log =
"processOutgoingPreformatted("+Fields.hashCode(buf)+", "+offset+ ',' +length+
',' +tracker+ ',' +packetNumber+ ',';
if(callbacks == null) log += "null";
@@ -2660,7 +2660,7 @@
private HashSet<Peer> peersWithProblems = new HashSet<Peer>();
- private void disconnectedStillNotAcked(KeyTracker tracker) {
+ private void disconnectedStillNotAcked(SessionKey tracker) {
synchronized(peersWithProblems) {
peersWithProblems.add(tracker.pn.getPeer());
if(peersWithProblems.size() > 1) return;
@@ -2765,7 +2765,7 @@
* @param plaintext The packet's plaintext, including all formatting,
* including acks and resend requests. Is clobbered.
*/
- private int processOutgoingFullyFormatted(byte[] plaintext, KeyTracker
kt) {
+ private int processOutgoingFullyFormatted(byte[] plaintext, SessionKey
kt) {
BlockCipher sessionCipher = kt.sessionCipher;
if(logMINOR) Logger.minor(this, "Encrypting with
"+HexUtil.bytesToHex(kt.sessionKey));
if(sessionCipher == null) {
@@ -2869,7 +2869,7 @@
return !((PeerNode)context).isConnected();
}
- public void resend(ResendPacketItem item, KeyTracker tracker) throws
PacketSequenceException, WouldBlockException, KeyChangedException,
NotConnectedException {
+ public void resend(ResendPacketItem item, SessionKey tracker) throws
PacketSequenceException, WouldBlockException, KeyChangedException,
NotConnectedException {
int size = processOutgoingPreformatted(item.buf, 0,
item.buf.length, tracker, item.packetNumber, item.callbacks, item.priority);
item.pn.resendByteCounter.sentBytes(size);
}
Modified: trunk/freenet/src/freenet/node/OutgoingPacketMangler.java
===================================================================
--- trunk/freenet/src/freenet/node/OutgoingPacketMangler.java 2008-12-16
23:35:49 UTC (rev 24395)
+++ trunk/freenet/src/freenet/node/OutgoingPacketMangler.java 2008-12-16
23:43:16 UTC (rev 24396)
@@ -34,9 +34,9 @@
/**
* Resend a single packet.
- * @param kt The KeyTracker on which to send the packet.
+ * @param kt The SessionKey on which to send the packet.
*/
- public void resend(ResendPacketItem item, KeyTracker kt) throws
PacketSequenceException, WouldBlockException, KeyChangedException,
NotConnectedException;
+ public void resend(ResendPacketItem item, SessionKey kt) throws
PacketSequenceException, WouldBlockException, KeyChangedException,
NotConnectedException;
/**
* Build a packet and send it. From a Message recently converted into
byte[],
@@ -46,7 +46,7 @@
* @return Total size including UDP headers of the sent packet.
*/
public int processOutgoing(byte[] buf, int offset, int length,
- KeyTracker tracker, short priority)
+ SessionKey tracker, short priority)
throws KeyChangedException, NotConnectedException,
PacketSequenceException, WouldBlockException;
@@ -57,7 +57,7 @@
* @param buf Buffer to read data from.
* @param offset Point at which to start reading.
* @param length Number of bytes to read.
- * @param tracker The KeyTracker to use to encrypt the packet and send
it to the
+ * @param tracker The SessionKey to use to encrypt the packet and send
it to the
* associated PeerNode.
* @param packetNumber If specified, force use of this particular
packet number.
* Means this is a resend of a dropped packet.
@@ -68,7 +68,7 @@
* @return The size of the sent packet.
*/
public int processOutgoingPreformatted(byte[] buf, int offset, int
length,
- KeyTracker tracker, int packetNumber,
+ SessionKey tracker, int packetNumber,
AsyncMessageCallback[] callbacks, short priority)
throws KeyChangedException, NotConnectedException,
PacketSequenceException, WouldBlockException;
Modified: trunk/freenet/src/freenet/node/PacketTracker.java
===================================================================
--- trunk/freenet/src/freenet/node/PacketTracker.java 2008-12-16 23:35:49 UTC
(rev 24395)
+++ trunk/freenet/src/freenet/node/PacketTracker.java 2008-12-16 23:43:16 UTC
(rev 24396)
@@ -30,7 +30,7 @@
* @author amphibian
*
* Class to track retransmissions, acknowledgements, packet numbers, etc.
- * May be shared by more than one KeyTracker (aka session key).
+ * May be shared by more than one SessionKey (aka session key).
*/
public class PacketTracker {
@@ -49,7 +49,7 @@
private final List<QueuedAck> ackQueue;
/** Serial numbers of packets that we have forgotten. Usually
* when we have forgotten a packet it just means that it has
- * been shifted to another KeyTracker because this one was
+ * been shifted to another SessionKey because this one was
* deprecated; the messages will get through in the end.
*/
private final List<QueuedForgotten> forgottenQueue;
@@ -947,9 +947,9 @@
}
/**
- * Clear the KeyTracker. Deprecate it, clear all resend, ack,
request-ack etc queues.
+ * Clear the SessionKey. Deprecate it, clear all resend, ack,
request-ack etc queues.
* Return the messages we still had in flight. The caller will then
either add them to
- * another KeyTracker, or call their callbacks to indicate failure.
+ * another SessionKey, or call their callbacks to indicate failure.
*/
private LimitedRangeIntByteArrayMapElement[] clear() {
if(logMINOR)
@@ -976,13 +976,13 @@
}
/**
- * Completely deprecate the KeyTracker, in favour of a new one.
- * It will no longer be used for anything. The KeyTracker will be
cleared and all outstanding packets
- * moved to the new KeyTracker.
+ * Completely deprecate the SessionKey, in favour of a new one.
+ * It will no longer be used for anything. The SessionKey will be
cleared and all outstanding packets
+ * moved to the new SessionKey.
*
- * *** Must only be called if the KeyTracker is not to be kept.
Otherwise, we may receive some packets twice. ***
+ * *** Must only be called if the SessionKey is not to be kept.
Otherwise, we may receive some packets twice. ***
*/
- public void completelyDeprecated(KeyTracker newTracker) {
+ public void completelyDeprecated(SessionKey newTracker) {
if(newTracker.packets == this) {
Logger.error(this, "Completely deprecated in favour of
self!", new Exception("debug"));
return;
Modified: trunk/freenet/src/freenet/node/PeerNode.java
===================================================================
--- trunk/freenet/src/freenet/node/PeerNode.java 2008-12-16 23:35:49 UTC
(rev 24395)
+++ trunk/freenet/src/freenet/node/PeerNode.java 2008-12-16 23:43:16 UTC
(rev 24396)
@@ -79,7 +79,7 @@
* is that we can rekey, or a node can go down and come back up
* while we are connected to it, and we want to reinitialize the
* packet numbers when this happens. Hence we separate a lot of
- * code into KeyTracker, which handles all communications to and
+ * code into SessionKey, which handles all communications to and
* from this peer over the duration of a single key.
*/
public abstract class PeerNode implements PeerContext, USKRetrieverCallback {
@@ -122,9 +122,9 @@
/** Is this a testnet node? */
public final boolean testnetEnabled;
/** Packets sent/received on the current preferred key */
- private KeyTracker currentTracker;
+ private SessionKey currentTracker;
/** Previous key - has a separate packet number space */
- private KeyTracker previousTracker;
+ private SessionKey previousTracker;
/** When did we last rekey (promote the unverified tracker to new) ? */
private long timeLastRekeyed;
/** How much data did we send with the current tracker ? */
@@ -134,7 +134,7 @@
/** Unverified tracker - will be promoted to currentTracker if
* we receive packets on it
*/
- private KeyTracker unverifiedTracker;
+ private SessionKey unverifiedTracker;
/** When did we last send a packet? */
private long timeLastSentPacket;
/** When did we last receive a packet? */
@@ -1131,7 +1131,7 @@
/**
* Disconnected e.g. due to not receiving a packet for ages.
* @param dumpMessageQueue If true, clear the messages-to-send queue.
- * @param dumpTrackers If true, dump the KeyTracker's.
+ * @param dumpTrackers If true, dump the SessionKey's.
* @return True if the node was connected, false if it was not.
*/
public boolean disconnected(boolean dumpMessageQueue, boolean
dumpTrackers) {
@@ -1141,7 +1141,7 @@
node.failureTable.onDisconnect(this);
node.peers.disconnected(this);
boolean ret;
- KeyTracker cur, prev, unv;
+ SessionKey cur, prev, unv;
MessageItem[] messagesTellDisconnected = null;
synchronized(this) {
ret = isConnected;
@@ -1267,13 +1267,13 @@
*/
public long getNextUrgentTime(long now) {
long t = Long.MAX_VALUE;
- KeyTracker cur;
- KeyTracker prev;
+ SessionKey cur;
+ SessionKey prev;
synchronized(this) {
cur = currentTracker;
prev = previousTracker;
}
- KeyTracker kt = cur;
+ SessionKey kt = cur;
if(kt != null) {
long next = kt.packets.getNextUrgentTime();
t = Math.min(t, next);
@@ -1300,7 +1300,7 @@
}
private synchronized boolean mustSendNotificationsNow(long now) {
- KeyTracker kt = currentTracker;
+ SessionKey kt = currentTracker;
if(kt != null) {
if(kt.packets.getNextUrgentTime() < now) return true;
}
@@ -1697,27 +1697,27 @@
}
/**
- * @return The current primary KeyTracker, or null if we
+ * @return The current primary SessionKey, or null if we
* don't have one.
*/
- public synchronized KeyTracker getCurrentKeyTracker() {
+ public synchronized SessionKey getCurrentKeyTracker() {
return currentTracker;
}
/**
- * @return The previous primary KeyTracker, or null if we
+ * @return The previous primary SessionKey, or null if we
* don't have one.
*/
- public synchronized KeyTracker getPreviousKeyTracker() {
+ public synchronized SessionKey getPreviousKeyTracker() {
return previousTracker;
}
/**
- * @return The unverified KeyTracker, if any, or null if we
+ * @return 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.
*/
- public synchronized KeyTracker getUnverifiedKeyTracker() {
+ public synchronized SessionKey getUnverifiedKeyTracker() {
return unverifiedTracker;
}
@@ -1875,10 +1875,10 @@
changedIP(replyTo);
boolean bootIDChanged = false;
boolean wasARekey = false;
- KeyTracker oldPrev = null;
- KeyTracker oldCur = null;
- KeyTracker prev = null;
- KeyTracker newTracker;
+ SessionKey oldPrev = null;
+ SessionKey oldCur = null;
+ SessionKey prev = null;
+ SessionKey newTracker;
MessageItem[] messagesTellDisconnected = null;
PacketTracker packets = null;
synchronized(this) {
@@ -1955,7 +1955,7 @@
} else {
// else it's a rekey
}
- newTracker = new KeyTracker(this, packets, encCipher,
encKey);
+ newTracker = new SessionKey(this, packets, encCipher,
encKey);
if(logMINOR) Logger.minor(this, "New key tracker in
completedHandshake: "+newTracker+" for "+packets+" for "+shortToString()+" neg
type "+negType);
if(unverified) {
if(unverifiedTracker != null) {
@@ -2064,16 +2064,16 @@
if(prevHash < curHash) {
// Swap over
- KeyTracker temp = previousTracker;
+ SessionKey temp = previousTracker;
previousTracker = currentTracker;
currentTracker = temp;
- if(logMINOR) Logger.minor(this, "Swapped
KeyTracker's on "+this+" cur "+currentTracker+" prev "+previousTracker+" delta
"+delta+" cur.deprecated="+currentTracker.packets.isDeprecated()+"
prev.deprecated="+previousTracker.packets.isDeprecated());
+ if(logMINOR) Logger.minor(this, "Swapped
SessionKey's on "+this+" cur "+currentTracker+" prev "+previousTracker+" delta
"+delta+" cur.deprecated="+currentTracker.packets.isDeprecated()+"
prev.deprecated="+previousTracker.packets.isDeprecated());
} else {
- if(logMINOR) Logger.minor(this, "Not swapping
KeyTracker's on "+this+" cur "+currentTracker+" prev "+previousTracker+" delta
"+delta+" cur.deprecated="+currentTracker.packets.isDeprecated()+"
prev.deprecated="+previousTracker.packets.isDeprecated());
+ if(logMINOR) Logger.minor(this, "Not swapping
SessionKey's on "+this+" cur "+currentTracker+" prev "+previousTracker+" delta
"+delta+" cur.deprecated="+currentTracker.packets.isDeprecated()+"
prev.deprecated="+previousTracker.packets.isDeprecated());
}
} else {
if (logMINOR)
- Logger.minor(this, "Not swapping KeyTracker's:
previousTracker = " + previousTracker.toString()
+ Logger.minor(this, "Not swapping SessionKey's:
previousTracker = " + previousTracker.toString()
+
(previousTracker.packets.isDeprecated() ? " (deprecated)" : "") + " time delta
= " + delta);
}
}
@@ -2202,12 +2202,12 @@
/**
* Called when a packet is successfully decrypted on a given
- * KeyTracker for this node. Will promote the unverifiedTracker
+ * SessionKey for this node. Will promote the unverifiedTracker
* if necessary.
*/
- public void verified(KeyTracker tracker) {
+ public void verified(SessionKey tracker) {
long now = System.currentTimeMillis();
- KeyTracker completelyDeprecatedTracker;
+ SessionKey completelyDeprecatedTracker;
synchronized(this) {
if(tracker == unverifiedTracker &&
!tracker.packets.isDeprecated()) {
if(logMINOR)
@@ -2491,13 +2491,13 @@
if(logMINOR)
Logger.minor(this, "sendAnyUrgentNotifications");
long now = System.currentTimeMillis();
- KeyTracker cur,
+ SessionKey cur,
prev;
synchronized(this) {
cur = currentTracker;
prev = previousTracker;
}
- KeyTracker tracker = cur;
+ SessionKey tracker = cur;
if(tracker != null) {
long t = tracker.packets.getNextUrgentTime();
if(t < now || forceSendPrimary) {
@@ -2541,8 +2541,8 @@
void checkTrackerTimeout() {
long now = System.currentTimeMillis();
- KeyTracker prev = null;
- KeyTracker cur = null;
+ SessionKey prev = null;
+ SessionKey cur = null;
synchronized(this) {
if(previousTracker == null) return;
if(currentTracker == null) return;
@@ -2712,7 +2712,7 @@
* @param resendItems
*/
public void requeueResendItems(Vector<ResendPacketItem> resendItems) {
- KeyTracker cur,
+ SessionKey cur,
prev,
unv;
synchronized(this) {
@@ -2723,7 +2723,7 @@
for(ResendPacketItem item : resendItems) {
if(item.pn != this)
throw new IllegalArgumentException("item.pn !=
this!");
- KeyTracker kt = cur;
+ SessionKey kt = cur;
if((kt != null) && (item.kt == kt.packets)) {
kt.packets.resendPacket(item.packetNumber);
continue;
@@ -4126,7 +4126,7 @@
}
// Any packets to resend? If so, resend ONE packet and then
return.
for(int j = 0; j < 2; j++) {
- KeyTracker kt;
+ SessionKey kt;
if(j == 0)
kt = getCurrentKeyTracker();
else// if(j == 1)
@@ -4251,7 +4251,7 @@
* @return The ID of a reusable PacketTracker if there is one,
otherwise -1.
*/
public long getReusableTrackerID() {
- KeyTracker cur;
+ SessionKey cur;
synchronized(this) {
cur = currentTracker;
}
_______________________________________________
cvs mailing list
[email protected]
http://emu.freenetproject.org/cgi-bin/mailman/listinfo/cvs
