Author: toad
Date: 2008-09-13 12:04:43 +0000 (Sat, 13 Sep 2008)
New Revision: 22640

Added:
   trunk/freenet/src/freenet/node/NodeToNodeMessageListener.java
Modified:
   trunk/freenet/src/freenet/node/Node.java
Log:
NodeToNodeMessageListener and Node.registerNodeToNodeMessageListener.
Hopefully will be used by plugins.


Modified: trunk/freenet/src/freenet/node/Node.java
===================================================================
--- trunk/freenet/src/freenet/node/Node.java    2008-09-13 02:54:09 UTC (rev 
22639)
+++ trunk/freenet/src/freenet/node/Node.java    2008-09-13 12:04:43 UTC (rev 
22640)
@@ -18,6 +18,7 @@
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Locale;
+import java.util.Map;
 import java.util.MissingResourceException;
 import java.util.Random;
 import java.util.Set;
@@ -1937,6 +1938,9 @@
                        throw new 
NodeInitException(NodeInitException.EXIT_COULD_NOT_START_UPDATER, "Could not 
create Updater: "+e);
                }

+               registerNodeToNodeMessageListener(N2N_MESSAGE_TYPE_FPROXY, 
fproxyN2NMListener);
+               
registerNodeToNodeMessageListener(Node.N2N_MESSAGE_TYPE_DIFFNODEREF, 
diffNoderefListener);
+               
                Logger.normal(this, "Node constructor completed");
                System.out.println("Node constructor completed");
        }
@@ -3119,6 +3123,12 @@
                return (buildOldAgeUserAlert.lastGoodVersion > 0);
        }

+       private Map<Integer, NodeToNodeMessageListener> n2nmListeners = new 
HashMap<Integer, NodeToNodeMessageListener>();
+       
+       public synchronized void registerNodeToNodeMessageListener(int type, 
NodeToNodeMessageListener listener) {
+               n2nmListeners.put(type, listener);
+       }
+       
        /**
         * Handle a received node to node message
         */
@@ -3133,20 +3143,56 @@
                if(src instanceof DarknetPeerNode) {
                        fromDarknet = true;
                }
-               DarknetPeerNode darkSource = null;
-               if(fromDarknet) {
-                       darkSource = (DarknetPeerNode)src;
+               
+               NodeToNodeMessageListener listener = null;
+               synchronized(this) {
+                       listener = n2nmListeners.get(type);
                }

-               if(type == Node.N2N_MESSAGE_TYPE_FPROXY) {
+               if(listener == null) {
+                       Logger.error(this, "Unknown n2nm ID: "+type+" - 
discarding packet length "+messageData.getLength());
+                       return;
+               }
+               
+               listener.handleMessage(messageData.getData(), fromDarknet, src, 
type);
+       }
+
+       private NodeToNodeMessageListener diffNoderefListener = new 
NodeToNodeMessageListener() {
+
+               public void handleMessage(byte[] data, boolean fromDarknet, 
PeerNode src, int type) {
+                       Logger.normal(this, "Received differential node 
reference node to node message from "+src.getPeer());
+                       SimpleFieldSet fs = null;
+                       try {
+                               fs = new SimpleFieldSet(new String(data, 
"UTF-8"), false, true);
+                       } catch (IOException e) {
+                               Logger.error(this, "IOException while parsing 
node to node message data", e);
+                               return;
+                       }
+                       if(fs.get("n2nType") != null) {
+                               fs.removeValue("n2nType");
+                       }
+                       try {
+                               src.processDiffNoderef(fs);
+                       } catch (FSParseException e) {
+                               Logger.error(this, "FSParseException while 
parsing node to node message data", e);
+                               return;
+                       }
+               }
+               
+       };
+       
+       private NodeToNodeMessageListener fproxyN2NMListener = new 
NodeToNodeMessageListener() {
+
+               public void handleMessage(byte[] data, boolean fromDarknet, 
PeerNode src, int type) {
                        if(!fromDarknet) {
                                Logger.error(this, "Got N2NTM from non-darknet 
node ?!?!?!: from "+src);
                                return;
                        }
+                       DarknetPeerNode darkSource = (DarknetPeerNode) src;
                        Logger.normal(this, "Received N2NTM from 
'"+darkSource.getPeer()+"'");
                        SimpleFieldSet fs = null;
                        try {
-                               fs = new SimpleFieldSet(new 
String(messageData.getData(), "UTF-8"), false, true);
+                               fs = new SimpleFieldSet(new String(data, 
"UTF-8"), false, true);
                        } catch (IOException e) {
                                Logger.error(this, "IOException while parsing 
node to node message data", e);
                                return;
@@ -3174,29 +3220,10 @@
                                // Shouldn't happen
                                throw new Error(e);
                        }
-               } else if(type == Node.N2N_MESSAGE_TYPE_DIFFNODEREF) {
-                       Logger.normal(this, "Received differential node 
reference node to node message from "+src.getPeer());
-                       SimpleFieldSet fs = null;
-                       try {
-                               fs = new SimpleFieldSet(new 
String(messageData.getData(), "UTF-8"), false, true);
-                       } catch (IOException e) {
-                               Logger.error(this, "IOException while parsing 
node to node message data", e);
-                               return;
-                       }
-                       if(fs.get("n2nType") != null) {
-                               fs.removeValue("n2nType");
-                       }
-                       try {
-                               src.processDiffNoderef(fs);
-                       } catch (FSParseException e) {
-                               Logger.error(this, "FSParseException while 
parsing node to node message data", e);
-                               return;
-                       }
-               } else {
-                       Logger.error(this, "Received unknown node to node 
message type '"+type+"' from "+src.getPeer());
                }
-       }
-
+               
+       };
+       
        /**
         * Handle a node to node text message SimpleFieldSet
         * @throws FSParseException 

Added: trunk/freenet/src/freenet/node/NodeToNodeMessageListener.java
===================================================================
--- trunk/freenet/src/freenet/node/NodeToNodeMessageListener.java               
                (rev 0)
+++ trunk/freenet/src/freenet/node/NodeToNodeMessageListener.java       
2008-09-13 12:04:43 UTC (rev 22640)
@@ -0,0 +1,11 @@
+package freenet.node;
+
+/**
+ * Something that wants to listen for nodeToNodeMessage's.
+ * @author Matthew Toseland <toad at amphibian.dyndns.org> (0xE43DA450)
+ */
+public interface NodeToNodeMessageListener {
+       
+       public void handleMessage(byte[] data, boolean fromDarknet, PeerNode 
source, int type);
+
+}


Reply via email to