cc13d4a6aac5a3d8214b68a724ddff1abcf8e982
[jFCPlib.git] / src / main / java / net / pterodactylus / fcp / FcpConnection.java
1 /*
2  * jFCPlib - FpcConnection.java - Copyright © 2008 David Roden
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  */
18
19 package net.pterodactylus.fcp;
20
21 import java.io.Closeable;
22 import java.io.FilterInputStream;
23 import java.io.IOException;
24 import java.io.InputStream;
25 import java.io.OutputStream;
26 import java.net.InetAddress;
27 import java.net.Socket;
28 import java.net.UnknownHostException;
29 import java.util.Collections;
30 import java.util.HashMap;
31 import java.util.Map;
32 import java.util.logging.Logger;
33
34 /**
35  * An FCP connection to a Freenet node.
36  *
37  * @author David ‘Bombe’ Roden <bombe@freenetproject.org>
38  */
39 public class FcpConnection implements Closeable {
40
41         /** Logger. */
42         private static final Logger logger = Logger.getLogger(FcpConnection.class.getName());
43
44         /** The default port for FCP v2. */
45         public static final int DEFAULT_PORT = 9481;
46
47         /** Listener management. */
48         private final FcpListenerManager fcpListenerManager = new FcpListenerManager(this);
49
50         /** The address of the node. */
51         private final InetAddress address;
52
53         /** The port number of the node’s FCP port. */
54         private final int port;
55
56         /** The remote socket. */
57         private Socket remoteSocket;
58
59         /** The input stream from the node. */
60         private InputStream remoteInputStream;
61
62         /** The output stream to the node. */
63         private OutputStream remoteOutputStream;
64
65         /** The connection handler. */
66         private FcpConnectionHandler connectionHandler;
67
68         /** Incoming message statistics. */
69         private static final Map<String, Integer> incomingMessageStatistics = Collections.synchronizedMap(new HashMap<String, Integer>());
70
71         /**
72          * Creates a new FCP connection to the freenet node running on localhost,
73          * using the default port.
74          *
75          * @throws UnknownHostException
76          *             if the hostname can not be resolved
77          */
78         public FcpConnection() throws UnknownHostException {
79                 this(InetAddress.getLocalHost());
80         }
81
82         /**
83          * Creates a new FCP connection to the Freenet node running on the given
84          * host, listening on the default port.
85          *
86          * @param host
87          *            The hostname of the Freenet node
88          * @throws UnknownHostException
89          *             if <code>host</code> can not be resolved
90          */
91         public FcpConnection(String host) throws UnknownHostException {
92                 this(host, DEFAULT_PORT);
93         }
94
95         /**
96          * Creates a new FCP connection to the Freenet node running on the given
97          * host, listening on the given port.
98          *
99          * @param host
100          *            The hostname of the Freenet node
101          * @param port
102          *            The port number of the node’s FCP port
103          * @throws UnknownHostException
104          *             if <code>host</code> can not be resolved
105          */
106         public FcpConnection(String host, int port) throws UnknownHostException {
107                 this(InetAddress.getByName(host), port);
108         }
109
110         /**
111          * Creates a new FCP connection to the Freenet node running at the given
112          * address, listening on the default port.
113          *
114          * @param address
115          *            The address of the Freenet node
116          */
117         public FcpConnection(InetAddress address) {
118                 this(address, DEFAULT_PORT);
119         }
120
121         /**
122          * Creates a new FCP connection to the Freenet node running at the given
123          * address, listening on the given port.
124          *
125          * @param address
126          *            The address of the Freenet node
127          * @param port
128          *            The port number of the node’s FCP port
129          */
130         public FcpConnection(InetAddress address, int port) {
131                 this.address = address;
132                 this.port = port;
133         }
134
135         public synchronized boolean isClosed() {
136                 return connectionHandler == null;
137         }
138
139         //
140         // LISTENER MANAGEMENT
141         //
142
143         /**
144          * Adds the given listener to the list of listeners.
145          *
146          * @param fcpListener
147          *            The listener to add
148          */
149         public void addFcpListener(FcpListener fcpListener) {
150                 fcpListenerManager.addListener(fcpListener);
151         }
152
153         /**
154          * Removes the given listener from the list of listeners.
155          *
156          * @param fcpListener
157          *            The listener to remove
158          */
159         public void removeFcpListener(FcpListener fcpListener) {
160                 fcpListenerManager.removeListener(fcpListener);
161         }
162
163         //
164         // ACTIONS
165         //
166
167         /**
168          * Connects to the node.
169          *
170          * @throws IOException
171          *             if an I/O error occurs
172          * @throws IllegalStateException
173          *             if there is already a connection to the node
174          */
175         public synchronized void connect() throws IOException, IllegalStateException {
176                 if (connectionHandler != null) {
177                         throw new IllegalStateException("already connected, disconnect first");
178                 }
179                 logger.info("connecting to " + address + ":" + port + "…");
180                 remoteSocket = new Socket(address, port);
181                 remoteInputStream = remoteSocket.getInputStream();
182                 remoteOutputStream = remoteSocket.getOutputStream();
183                 new Thread(connectionHandler = new FcpConnectionHandler(this, remoteInputStream)).start();
184         }
185
186         /**
187          * Disconnects from the node. If there is no connection to the node, this
188          * method does nothing.
189          *
190          * @deprecated Use {@link #close()} instead
191          */
192         @Deprecated
193         public synchronized void disconnect() {
194                 close();
195         }
196
197         /**
198          * Closes the connection. If there is no connection to the node, this
199          * method does nothing.
200          */
201         @Override
202         public void close() {
203                 handleDisconnect(null);
204         }
205
206         /**
207          * Sends the given FCP message.
208          *
209          * @param fcpMessage
210          *            The FCP message to send
211          * @throws IOException
212          *             if an I/O error occurs
213          */
214         public synchronized void sendMessage(FcpMessage fcpMessage) throws IOException {
215                 logger.fine("sending message: " + fcpMessage.getName());
216                 fcpMessage.write(remoteOutputStream);
217         }
218
219         //
220         // PACKAGE-PRIVATE METHODS
221         //
222
223         /**
224          * Handles the given message, notifying listeners. This message should only
225          * be called by {@link FcpConnectionHandler}.
226          *
227          * @param fcpMessage
228          *            The received message
229          */
230         void handleMessage(FcpMessage fcpMessage) {
231                 logger.fine("received message: " + fcpMessage.getName());
232                 String messageName = fcpMessage.getName();
233                 countMessage(messageName);
234                 if ("SimpleProgress".equals(messageName)) {
235                         fcpListenerManager.fireReceivedSimpleProgress(new SimpleProgress(fcpMessage));
236                 } else if ("ProtocolError".equals(messageName)) {
237                         fcpListenerManager.fireReceivedProtocolError(new ProtocolError(fcpMessage));
238                 } else if ("PersistentGet".equals(messageName)) {
239                         fcpListenerManager.fireReceivedPersistentGet(new PersistentGet(fcpMessage));
240                 } else if ("PersistentPut".equals(messageName)) {
241                         fcpListenerManager.fireReceivedPersistentPut(new PersistentPut(fcpMessage));
242                 } else if ("PersistentPutDir".equals(messageName)) {
243                         fcpListenerManager.fireReceivedPersistentPutDir(new PersistentPutDir(fcpMessage));
244                 } else if ("URIGenerated".equals(messageName)) {
245                         fcpListenerManager.fireReceivedURIGenerated(new URIGenerated(fcpMessage));
246                 } else if ("EndListPersistentRequests".equals(messageName)) {
247                         fcpListenerManager.fireReceivedEndListPersistentRequests(new EndListPersistentRequests(fcpMessage));
248                 } else if ("Peer".equals(messageName)) {
249                         fcpListenerManager.fireReceivedPeer(new Peer(fcpMessage));
250                 } else if ("PeerNote".equals(messageName)) {
251                         fcpListenerManager.fireReceivedPeerNote(new PeerNote(fcpMessage));
252                 } else if ("StartedCompression".equals(messageName)) {
253                         fcpListenerManager.fireReceivedStartedCompression(new StartedCompression(fcpMessage));
254                 } else if ("FinishedCompression".equals(messageName)) {
255                         fcpListenerManager.fireReceivedFinishedCompression(new FinishedCompression(fcpMessage));
256                 } else if ("GetFailed".equals(messageName)) {
257                         fcpListenerManager.fireReceivedGetFailed(new GetFailed(fcpMessage));
258                 } else if ("PutFetchable".equals(messageName)) {
259                         fcpListenerManager.fireReceivedPutFetchable(new PutFetchable(fcpMessage));
260                 } else if ("PutSuccessful".equals(messageName)) {
261                         fcpListenerManager.fireReceivedPutSuccessful(new PutSuccessful(fcpMessage));
262                 } else if ("PutFailed".equals(messageName)) {
263                         fcpListenerManager.fireReceivedPutFailed(new PutFailed(fcpMessage));
264                 } else if ("DataFound".equals(messageName)) {
265                         fcpListenerManager.fireReceivedDataFound(new DataFound(fcpMessage));
266                 } else if ("SubscribedUSKUpdate".equals(messageName)) {
267                         fcpListenerManager.fireReceivedSubscribedUSKUpdate(new SubscribedUSKUpdate(fcpMessage));
268                 } else if ("IdentifierCollision".equals(messageName)) {
269                         fcpListenerManager.fireReceivedIdentifierCollision(new IdentifierCollision(fcpMessage));
270                 } else if ("AllData".equals(messageName)) {
271                         LimitedInputStream payloadInputStream = getInputStream(FcpUtils.safeParseLong(fcpMessage.getField("DataLength")));
272                         fcpListenerManager.fireReceivedAllData(new AllData(fcpMessage, payloadInputStream));
273                         try {
274                                 payloadInputStream.consume();
275                         } catch (IOException ioe1) {
276                                 /* well, ignore. when the connection handler fails, all fails. */
277                         }
278                 } else if ("EndListPeerNotes".equals(messageName)) {
279                         fcpListenerManager.fireReceivedEndListPeerNotes(new EndListPeerNotes(fcpMessage));
280                 } else if ("EndListPeers".equals(messageName)) {
281                         fcpListenerManager.fireReceivedEndListPeers(new EndListPeers(fcpMessage));
282                 } else if ("SSKKeypair".equals(messageName)) {
283                         fcpListenerManager.fireReceivedSSKKeypair(new SSKKeypair(fcpMessage));
284                 } else if ("PeerRemoved".equals(messageName)) {
285                         fcpListenerManager.fireReceivedPeerRemoved(new PeerRemoved(fcpMessage));
286                 } else if ("PersistentRequestModified".equals(messageName)) {
287                         fcpListenerManager.fireReceivedPersistentRequestModified(new PersistentRequestModified(fcpMessage));
288                 } else if ("PersistentRequestRemoved".equals(messageName)) {
289                         fcpListenerManager.fireReceivedPersistentRequestRemoved(new PersistentRequestRemoved(fcpMessage));
290                 } else if ("UnknownPeerNoteType".equals(messageName)) {
291                         fcpListenerManager.fireReceivedUnknownPeerNoteType(new UnknownPeerNoteType(fcpMessage));
292                 } else if ("UnknownNodeIdentifier".equals(messageName)) {
293                         fcpListenerManager.fireReceivedUnknownNodeIdentifier(new UnknownNodeIdentifier(fcpMessage));
294                 } else if ("FCPPluginReply".equals(messageName)) {
295                         LimitedInputStream payloadInputStream = getInputStream(FcpUtils.safeParseLong(fcpMessage.getField("DataLength")));
296                         fcpListenerManager.fireReceivedFCPPluginReply(new FCPPluginReply(fcpMessage, payloadInputStream));
297                         try {
298                                 payloadInputStream.consume();
299                         } catch (IOException ioe1) {
300                                 /* ignore. */
301                         }
302                 } else if ("PluginInfo".equals(messageName)) {
303                         fcpListenerManager.fireReceivedPluginInfo(new PluginInfo(fcpMessage));
304                 } else if ("NodeData".equals(messageName)) {
305                         fcpListenerManager.fireReceivedNodeData(new NodeData(fcpMessage));
306                 } else if ("TestDDAReply".equals(messageName)) {
307                         fcpListenerManager.fireReceivedTestDDAReply(new TestDDAReply(fcpMessage));
308                 } else if ("TestDDAComplete".equals(messageName)) {
309                         fcpListenerManager.fireReceivedTestDDAComplete(new TestDDAComplete(fcpMessage));
310                 } else if ("ConfigData".equals(messageName)) {
311                         fcpListenerManager.fireReceivedConfigData(new ConfigData(fcpMessage));
312                 } else if ("NodeHello".equals(messageName)) {
313                         fcpListenerManager.fireReceivedNodeHello(new NodeHello(fcpMessage));
314                 } else if ("CloseConnectionDuplicateClientName".equals(messageName)) {
315                         fcpListenerManager.fireReceivedCloseConnectionDuplicateClientName(new CloseConnectionDuplicateClientName(fcpMessage));
316                 } else if ("SentFeed".equals(messageName)) {
317                         fcpListenerManager.fireSentFeed(new SentFeed(fcpMessage));
318                 } else if ("ReceivedBookmarkFeed".equals(messageName)) {
319                         fcpListenerManager.fireReceivedBookmarkFeed(new ReceivedBookmarkFeed(fcpMessage));
320                 } else {
321                         fcpListenerManager.fireMessageReceived(fcpMessage);
322                 }
323         }
324
325         /**
326          * Handles a disconnect from the node.
327          *
328          * @param throwable
329          *            The exception that caused the disconnect, or
330          *            <code>null</code> if there was no exception
331          */
332         synchronized void handleDisconnect(Throwable throwable) {
333                 FcpUtils.close(remoteInputStream);
334                 FcpUtils.close(remoteOutputStream);
335                 FcpUtils.close(remoteSocket);
336                 if (connectionHandler != null) {
337                         connectionHandler.stop();
338                         connectionHandler = null;
339                         fcpListenerManager.fireConnectionClosed(throwable);
340                 }
341         }
342
343         //
344         // PRIVATE METHODS
345         //
346
347         /**
348          * Incremets the counter in {@link #incomingMessageStatistics} by
349          * <cod>1</code> for the given message name.
350          *
351          * @param name
352          *            The name of the message to count
353          */
354         private void countMessage(String name) {
355                 int oldValue = 0;
356                 if (incomingMessageStatistics.containsKey(name)) {
357                         oldValue = incomingMessageStatistics.get(name);
358                 }
359                 incomingMessageStatistics.put(name, oldValue + 1);
360                 logger.finest("count for " + name + ": " + (oldValue + 1));
361         }
362
363         /**
364          * Returns a limited input stream from the node’s input stream.
365          *
366          * @param dataLength
367          *            The length of the stream
368          * @return The limited input stream
369          */
370         private synchronized LimitedInputStream getInputStream(long dataLength) {
371                 if (dataLength <= 0) {
372                         return new LimitedInputStream(null, 0);
373                 }
374                 return new LimitedInputStream(remoteInputStream, dataLength);
375         }
376
377         /**
378          * A wrapper around an {@link InputStream} that only supplies a limit
379          * number of bytes from the underlying input stream.
380          *
381          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
382          */
383         private static class LimitedInputStream extends FilterInputStream {
384
385                 /** The remaining number of bytes that can be read. */
386                 private long remaining;
387
388                 /**
389                  * Creates a new LimitedInputStream that supplies at most
390                  * <code>length</code> bytes from the given input stream.
391                  *
392                  * @param inputStream
393                  *            The input stream
394                  * @param length
395                  *            The number of bytes to read
396                  */
397                 public LimitedInputStream(InputStream inputStream, long length) {
398                         super(inputStream);
399                         remaining = length;
400                 }
401
402                 /**
403                  * @see java.io.FilterInputStream#available()
404                  */
405                 @Override
406                 public synchronized int available() throws IOException {
407                         if (remaining == 0) {
408                                 return 0;
409                         }
410                         return (int) Math.min(super.available(), Math.min(Integer.MAX_VALUE, remaining));
411                 }
412
413                 /**
414                  * @see java.io.FilterInputStream#read()
415                  */
416                 @Override
417                 public synchronized int read() throws IOException {
418                         int read = -1;
419                         if (remaining > 0) {
420                                 read = super.read();
421                                 remaining--;
422                         }
423                         return read;
424                 }
425
426                 /**
427                  * @see java.io.FilterInputStream#read(byte[], int, int)
428                  */
429                 @Override
430                 public synchronized int read(byte[] b, int off, int len) throws IOException {
431                         if (remaining == 0) {
432                                 return -1;
433                         }
434                         int toCopy = (int) Math.min(len, Math.min(remaining, Integer.MAX_VALUE));
435                         int read = super.read(b, off, toCopy);
436                         remaining -= read;
437                         return read;
438                 }
439
440                 /**
441                  * @see java.io.FilterInputStream#skip(long)
442                  */
443                 @Override
444                 public synchronized long skip(long n) throws IOException {
445                         if ((n < 0) || (remaining == 0)) {
446                                 return 0;
447                         }
448                         long skipped = super.skip(Math.min(n, remaining));
449                         remaining -= skipped;
450                         return skipped;
451                 }
452
453                 /**
454                  * {@inheritDoc} This method does nothing, as {@link #mark(int)} and
455                  * {@link #reset()} are not supported.
456                  *
457                  * @see java.io.FilterInputStream#mark(int)
458                  */
459                 @Override
460                 public synchronized void mark(int readlimit) {
461                         /* do nothing. */
462                 }
463
464                 /**
465                  * {@inheritDoc}
466                  *
467                  * @see java.io.FilterInputStream#markSupported()
468                  * @return <code>false</code>
469                  */
470                 @Override
471                 public boolean markSupported() {
472                         return false;
473                 }
474
475                 /**
476                  * {@inheritDoc} This method does nothing, as {@link #mark(int)} and
477                  * {@link #reset()} are not supported.
478                  *
479                  * @see java.io.FilterInputStream#reset()
480                  */
481                 @Override
482                 public synchronized void reset() throws IOException {
483                         /* do nothing. */
484                 }
485
486                 /**
487                  * Consumes the input stream, i.e. read all bytes until the limit is
488                  * reached.
489                  *
490                  * @throws IOException
491                  *             if an I/O error occurs
492                  */
493                 public synchronized void consume() throws IOException {
494                         while (remaining > 0) {
495                                 skip(remaining);
496                         }
497                 }
498
499         }
500
501 }