import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import net.pterodactylus.util.io.Closer;
import net.pterodactylus.util.io.LimitedInputStream;
/** The connection handler. */
private FcpConnectionHandler connectionHandler;
+ /** Incoming message statistics. */
+ private Map<String, Integer> incomingMessageStatistics = Collections.synchronizedMap(new HashMap<String, Integer>());
+
+ /**
+ * Creates a new FCP connection to the freenet node running on localhost,
+ * using the default port.
+ *
+ * @throws UnknownHostException
+ * if the hostname can not be resolved
+ */
+ public FcpConnection() throws UnknownHostException {
+ this(InetAddress.getLocalHost());
+ }
+
/**
* Creates a new FCP connection to the Freenet node running on the given
* host, listening on the default port.
}
/**
+ * Notifies all listeners that a “PersistentGet” message was received.
+ *
+ * @param persistentGet
+ * The “PersistentGet” message
+ */
+ private void fireReceivedPersistentGet(PersistentGet persistentGet) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedPersistentGet(this, persistentGet);
+ }
+ }
+
+ /**
* Notifies all listeners that a “PersistentPut” message was received.
*
* @see FcpListener#receivedPersistentPut(FcpConnection, PersistentPut)
}
/**
+ * Notifies all listeners that a “DataFound” message was received.
+ *
+ * @param dataFound
+ * The “DataFound” message
+ */
+ private void fireReceivedDataFound(DataFound dataFound) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedDataFound(this, dataFound);
+ }
+ }
+
+ /**
* Notifies all listeners that an “AllData” message was received.
*
* @param allData
}
/**
+ * Notifies all listeners that a “SimpleProgress” message was received.
+ *
+ * @param simpleProgress
+ * The “SimpleProgress” message
+ */
+ private void fireReceivedSimpleProgress(SimpleProgress simpleProgress) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedSimpleProgress(this, simpleProgress);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “StartedCompression” message was received.
+ *
+ * @param startedCompression
+ * The “StartedCompression” message
+ */
+ private void fireReceivedStartedCompression(StartedCompression startedCompression) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedStartedCompression(this, startedCompression);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “FinishedCompression” message was received.
+ *
+ * @param finishedCompression
+ * The “FinishedCompression” message
+ */
+ private void fireReceivedFinishedCompression(FinishedCompression finishedCompression) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receviedFinishedCompression(this, finishedCompression);
+ }
+ }
+
+ /**
+ * Notifies all listeners that an “UnknownPeerNoteType” message was
+ * received.
+ *
+ * @param unknownPeerNoteType
+ * The “UnknownPeerNoteType” message
+ */
+ private void fireReceivedUnknownPeerNoteType(UnknownPeerNoteType unknownPeerNoteType) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedUnknownPeerNoteType(this, unknownPeerNoteType);
+ }
+ }
+
+ /**
+ * Notifies all listeners that an “UnknownNodeIdentifier” message was
+ * received.
+ *
+ * @param unknownNodeIdentifier
+ * The “UnknownNodeIdentifier” message
+ */
+ private void fireReceivedUnknownNodeIdentifier(UnknownNodeIdentifier unknownNodeIdentifier) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedUnknownNodeIdentifier(this, unknownNodeIdentifier);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “ConfigData” message was received.
+ *
+ * @param configData
+ * The “ConfigData” message
+ */
+ private void fireReceivedConfigData(ConfigData configData) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedConfigData(this, configData);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “GetFailed” message was received.
+ *
+ * @param getFailed
+ * The “GetFailed” message
+ */
+ private void fireReceivedGetFailed(GetFailed getFailed) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedGetFailed(this, getFailed);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “PutFailed” message was received.
+ *
+ * @param putFailed
+ * The “PutFailed” message
+ */
+ private void fireReceivedPutFailed(PutFailed putFailed) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedPutFailed(this, putFailed);
+ }
+ }
+
+ /**
+ * Notifies all listeners that an “IdentifierCollision” message was
+ * received.
+ *
+ * @param identifierCollision
+ * The “IdentifierCollision” message
+ */
+ private void fireReceivedIdentifierCollision(IdentifierCollision identifierCollision) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedIdentifierCollision(this, identifierCollision);
+ }
+ }
+
+ /**
* Notifies all listeners that a “ProtocolError” message was received.
*
* @param protocolError
*/
void handleMessage(FcpMessage fcpMessage) {
String messageName = fcpMessage.getName();
- if ("ProtocolError".equals(messageName)) {
+ countMessage(messageName);
+ if ("SimpleProgress".equals(messageName)) {
+ fireReceivedSimpleProgress(new SimpleProgress(fcpMessage));
+ } else if ("ProtocolError".equals(messageName)) {
fireReceivedProtocolError(new ProtocolError(fcpMessage));
+ } else if ("PersistentGet".equals(messageName)) {
+ fireReceivedPersistentGet(new PersistentGet(fcpMessage));
} else if ("PersistentPut".equals(messageName)) {
fireReceivedPersistentPut(new PersistentPut(fcpMessage));
} else if ("URIGenerated".equals(messageName)) {
fireReceivedPeer(new Peer(fcpMessage));
} else if ("PeerNote".equals(messageName)) {
fireReceivedPeerNote(new PeerNote(fcpMessage));
+ } else if ("StartedCompression".equals(messageName)) {
+ fireReceivedStartedCompression(new StartedCompression(fcpMessage));
+ } else if ("FinishedCompression".equals(messageName)) {
+ fireReceivedFinishedCompression(new FinishedCompression(fcpMessage));
+ } else if ("GetFailed".equals(messageName)) {
+ fireReceivedGetFailed(new GetFailed(fcpMessage));
+ } else if ("PutFailed".equals(messageName)) {
+ fireReceivedPutFailed(new PutFailed(fcpMessage));
+ } else if ("DataFound".equals(messageName)) {
+ fireReceivedDataFound(new DataFound(fcpMessage));
+ } else if ("IdentifierCollision".equals(messageName)) {
+ fireReceivedIdentifierCollision(new IdentifierCollision(fcpMessage));
} else if ("AllData".equals(messageName)) {
long dataLength;
try {
fireReceivedSSKKeypair(new SSKKeypair(fcpMessage));
} else if ("PeerRemoved".equals(messageName)) {
fireReceivedPeerRemoved(new PeerRemoved(fcpMessage));
+ } else if ("UnknownPeerNoteType".equals(messageName)) {
+ fireReceivedUnknownPeerNoteType(new UnknownPeerNoteType(fcpMessage));
+ } else if ("UnknownNodeIdentifier".equals(messageName)) {
+ fireReceivedUnknownNodeIdentifier(new UnknownNodeIdentifier(fcpMessage));
} else if ("NodeData".equals(messageName)) {
fireReceivedNodeData(new NodeData(fcpMessage));
} else if ("TestDDAReply".equals(messageName)) {
fireReceivedTestDDAReply(new TestDDAReply(fcpMessage));
} else if ("TestDDAComplete".equals(messageName)) {
fireReceivedTestDDAComplete(new TestDDAComplete(fcpMessage));
+ } else if ("ConfigData".equals(messageName)) {
+ fireReceivedConfigData(new ConfigData(fcpMessage));
} else if ("NodeHello".equals(messageName)) {
fireReceivedNodeHello(new NodeHello(fcpMessage));
} else if ("CloseConnectionDuplicateClientName".equals(messageName)) {
}
}
+ /**
+ * Handles a disconnect from the node.
+ */
+ synchronized void handleDisconnect() {
+ Closer.close(remoteInputStream);
+ Closer.close(remoteOutputStream);
+ Closer.close(remoteSocket);
+ connectionHandler = null;
+ }
+
+ //
+ // PRIVATE METHODS
+ //
+
+ /**
+ * Incremets the counter in {@link #incomingMessageStatistics} by <cod>1</code>
+ * for the given message name.
+ *
+ * @param name
+ * The name of the message to count
+ */
+ private void countMessage(String name) {
+ int oldValue = 0;
+ if (incomingMessageStatistics.containsKey(name)) {
+ oldValue = incomingMessageStatistics.get(name);
+ }
+ incomingMessageStatistics.put(name, oldValue + 1);
+ }
+
}