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 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 an “PersistentPutDir” message was received.
+ *
+ * @param persistentPutDir
+ * The “PersistentPutDir” message
+ */
+ private void fireReceivedPersistentPutDir(PersistentPutDir persistentPutDir) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedPersistentPutDir(this, persistentPutDir);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “PersistentRequestRemoved” message was
+ * received.
+ *
+ * @param persistentRequestRemoved
+ * The “PersistentRequestRemoved” message
+ */
+ private void fireReceivedPersistentRequestRemoved(PersistentRequestRemoved persistentRequestRemoved) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedPersistentRequestRemoved(this, persistentRequestRemoved);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “SubscribedUSKUpdate” message was received.
+ *
+ * @param subscribedUSKUpdate
+ * The “SubscribedUSKUpdate” message
+ */
+ private void fireReceivedSubscribedUSKUpdate(SubscribedUSKUpdate subscribedUSKUpdate) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedSubscribedUSKUpdate(this, subscribedUSKUpdate);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a “PluginInfo” message was received.
+ *
+ * @param pluginInfo
+ * The “PluginInfo” message
+ */
+ private void fireReceivedPluginInfo(PluginInfo pluginInfo) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedPluginInfo(this, pluginInfo);
+ }
+ }
+
+ /**
+ * Notifies all listeners that an “FCPPluginReply” message was received.
+ *
+ * @param fcpPluginReply
+ * The “FCPPluginReply” message
+ */
+ private void fireReceivedFCPPluginReply(FCPPluginReply fcpPluginReply) {
+ for (FcpListener fcpListener: fcpListeners) {
+ fcpListener.receivedFCPPluginReply(this, fcpPluginReply);
+ }
+ }
+
+ /**
* Notifies all listeners that a “ProtocolError” message was received.
*
* @param protocolError
*/
void handleMessage(FcpMessage fcpMessage) {
String messageName = fcpMessage.getName();
+ 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 ("PersistentPutDir".equals(messageName)) {
+ fireReceivedPersistentPutDir(new PersistentPutDir(fcpMessage));
} else if ("URIGenerated".equals(messageName)) {
fireReceivedURIGenerated(new URIGenerated(fcpMessage));
} else if ("EndListPersistentRequests".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 ("SubscribedUSKUpdate".equals(messageName)) {
+ fireReceivedSubscribedUSKUpdate(new SubscribedUSKUpdate(fcpMessage));
+ } else if ("IdentifierCollision".equals(messageName)) {
+ fireReceivedIdentifierCollision(new IdentifierCollision(fcpMessage));
} else if ("AllData".equals(messageName)) {
- long dataLength;
- try {
- dataLength = Long.valueOf(fcpMessage.getField("DataLength"));
- } catch (NumberFormatException nfe1) {
- dataLength = -1;
- }
- LimitedInputStream payloadInputStream = new LimitedInputStream(remoteInputStream, dataLength);
+ LimitedInputStream payloadInputStream = getInputStream(FcpUtils.safeParseLong(fcpMessage.getField("DataLength")));
fireReceivedAllData(new AllData(fcpMessage, payloadInputStream));
try {
payloadInputStream.consume();
} catch (IOException ioe1) {
- /* FIXME - what now? */
/* well, ignore. when the connection handler fails, all fails. */
}
} else if ("EndListPeerNotes".equals(messageName)) {
fireReceivedSSKKeypair(new SSKKeypair(fcpMessage));
} else if ("PeerRemoved".equals(messageName)) {
fireReceivedPeerRemoved(new PeerRemoved(fcpMessage));
+ } else if ("PersistentRequestRemoved".equals(messageName)) {
+ fireReceivedPersistentRequestRemoved(new PersistentRequestRemoved(fcpMessage));
+ } else if ("UnknownPeerNoteType".equals(messageName)) {
+ fireReceivedUnknownPeerNoteType(new UnknownPeerNoteType(fcpMessage));
+ } else if ("UnknownNodeIdentifier".equals(messageName)) {
+ fireReceivedUnknownNodeIdentifier(new UnknownNodeIdentifier(fcpMessage));
+ } else if ("FCPPluginReply".equals(messageName)) {
+ LimitedInputStream payloadInputStream = getInputStream(FcpUtils.safeParseLong(fcpMessage.getField("DataLength")));
+ fireReceivedFCPPluginReply(new FCPPluginReply(fcpMessage, payloadInputStream));
+ try {
+ payloadInputStream.consume();
+ } catch (IOException ioe1) {
+ /* ignore. */
+ }
+ } else if ("PluginInfo".equals(messageName)) {
+ fireReceivedPluginInfo(new PluginInfo(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);
+ }
+
+ /**
+ * Returns a limited input stream from the node’s input stream.
+ *
+ * @param dataLength
+ * The length of the stream
+ * @return The limited input stream
+ */
+ private LimitedInputStream getInputStream(long dataLength) {
+ if (dataLength <= 0) {
+ return new LimitedInputStream(null, 0);
+ }
+ return new LimitedInputStream(remoteInputStream, dataLength);
+ }
+
}