Reverted JM-782

git-svn-id: http://svn.igniterealtime.org/svn/repos/wildfire/trunk@5418 b35dd754-fafc-0310-a699-88a17e54d16e

src/java/org/jivesoftware/wildfire/filetransfer/FileTransferProgress.java

@@ -11,8 +11,8 @@
 package org.jivesoftware.wildfire.filetransfer;
 
 import java.util.concurrent.Future;
-import java.nio.channels.ReadableByteChannel;
-import java.nio.channels.WritableByteChannel;
+import java.io.InputStream;
+import java.io.OutputStream;
 
 /**
  * An interface to track the progress of a file transfer through the server. This interface is used
@@ -58,11 +58,11 @@ public interface FileTransferProgress {
      */
     public void setTransferFuture(Future<?> future);
 
-    public void setInputChannel(ReadableByteChannel inputChannel);
+    public void setInputStream(InputStream initiatorInputStream);
 
-    public ReadableByteChannel getInputChannel();
+    public InputStream getInputStream();
 
-    public void setOutputChannel(WritableByteChannel outputChannel);
+    public void setOutputStream(OutputStream targetOutputStream);
 
-    public WritableByteChannel getOutputChannel();
+    public OutputStream getOutputStream();
 }

src/java/org/jivesoftware/wildfire/filetransfer/proxy/DefaultProxyTransfer.java

@@ -14,9 +14,8 @@ import org.jivesoftware.util.CacheSizes;
 
 import java.util.concurrent.Future;
 import java.io.IOException;
-import java.nio.channels.ReadableByteChannel;
-import java.nio.channels.WritableByteChannel;
-import java.nio.ByteBuffer;
+import java.io.InputStream;
+import java.io.OutputStream;
 
 /**
  * Tracks the different connections related to a file transfer. There are two connections, the
@@ -26,9 +25,9 @@ public class DefaultProxyTransfer implements ProxyTransfer {
 
     private String initiator;
 
-    private ReadableByteChannel inputStream;
+    private InputStream inputStream;
 
-    private WritableByteChannel outputStream;
+    private OutputStream outputStream;
 
     private String target;
 
@@ -53,20 +52,20 @@ public class DefaultProxyTransfer implements ProxyTransfer {
         this.initiator = initiator;
     }
 
-    public ReadableByteChannel getInputChannel() {
+    public InputStream getInputStream() {
         return inputStream;
     }
 
-    public void setInputChannel(ReadableByteChannel inputChannel) {
-        this.inputStream = inputChannel;
+    public void setInputStream(InputStream initiatorInputStream) {
+        this.inputStream = initiatorInputStream;
     }
 
-    public WritableByteChannel getOutputChannel() {
+    public OutputStream getOutputStream() {
         return outputStream;
     }
 
-    public void setOutputChannel(WritableByteChannel outputChannel) {
-        this.outputStream = outputChannel;
+    public void setOutputStream(OutputStream outputStream) {
+        this.outputStream = outputStream;
     }
 
     public String getTarget() {
@@ -113,27 +112,25 @@ public class DefaultProxyTransfer implements ProxyTransfer {
         if(!isActivatable()) {
             throw new IOException("Transfer missing party");
         }
-        ReadableByteChannel in = getInputChannel();
-        WritableByteChannel out = new ProxyOutputChannel(getOutputChannel());
+        InputStream in = getInputStream();
+        OutputStream out = new ProxyOutputStream(getOutputStream());
 
-        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
+        final byte[] b = new byte[BUFFER_SIZE];
         int count = 0;
         amountWritten = 0;
 
         do {
-            // write to the output channel
-            out.write(buffer);
+            // write to the output stream
+            out.write(b, 0, count);
 
             amountWritten += count;
 
-            // read more bytes from the input channel
-            buffer.clear();
-            count = in.read(buffer);
-            buffer.flip();
+            // read more bytes from the input stream
+            count = in.read(b);
         } while (count >= 0);
 
-        in.close();
-        out.close();
+        getInputStream().close();
+        getOutputStream().close();
     }
 
     public int getCachedSize() {

src/java/org/jivesoftware/wildfire/filetransfer/proxy/ProxyConnectionManager.java

@@ -20,15 +20,13 @@ import org.jivesoftware.wildfire.stats.i18nStatistic;
 import org.xmpp.packet.JID;
 
 import java.io.*;
-import java.net.*;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.InetAddress;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
-import java.nio.channels.ServerSocketChannel;
-import java.nio.channels.SocketChannel;
-import java.nio.channels.WritableByteChannel;
-import java.nio.ByteBuffer;
 
 /**
  * Manages the connections to the proxy server. The connections go through two stages before
@@ -50,14 +48,14 @@ public class ProxyConnectionManager {
 
     private Future<?> socketProcess;
 
+    private ServerSocket serverSocket;
+
     private int proxyPort;
 
     private FileTransferManager transferManager;
 
     private String className;
 
-    private ServerSocketChannel serverChannel;
-
     public ProxyConnectionManager(FileTransferManager manager) {
         String cacheName = "File Transfer";
         connectionMap = new Cache<String, ProxyTransfer>(cacheName, -1, 1000 * 60 * 10);
@@ -82,23 +80,20 @@ public class ProxyConnectionManager {
         reset();
         socketProcess = executor.submit(new Runnable() {
             public void run() {
-                ServerSocket serverSocket;
                 try {
-                    serverChannel = ServerSocketChannel.open();
-                    serverSocket = serverChannel.socket();
-                    serverSocket.bind(new InetSocketAddress(bindInterface, port));
+                    serverSocket = new ServerSocket(port, -1, bindInterface);
                 }
                 catch (IOException e) {
-                    Log.error("Error binding server socket", e);
+                    Log.error("Error creating server socket", e);
                     return;
                 }
                 while (serverSocket.isBound()) {
-                    final SocketChannel channel;
+                    final Socket socket;
                     try {
-                        channel = serverChannel.accept();
+                        socket = serverSocket.accept();
                     }
                     catch (IOException e) {
-                        if (serverChannel.isOpen()) {
+                        if (!serverSocket.isClosed()) {
                             Log.error("Error accepting proxy connection", e);
                             continue;
                         }
@@ -109,13 +104,13 @@ public class ProxyConnectionManager {
                     executor.submit(new Runnable() {
                         public void run() {
                             try {
-                                processConnection(channel);
+                                processConnection(socket);
                             }
                             catch (IOException ie) {
                                 Log.error("Error processing file transfer proxy connection",
                                         ie);
                                 try {
-                                    channel.close();
+                                    socket.close();
                                 }
                                 catch (IOException e) {
                                     /* Do Nothing */
@@ -133,21 +128,21 @@ public class ProxyConnectionManager {
         return proxyPort;
     }
 
-    private void processConnection(SocketChannel connection) throws IOException {
-        ByteBuffer buffer = ByteBuffer.allocate(512);
-        connection.read(buffer);
-        buffer.flip();
+    private void processConnection(Socket connection) throws IOException {
+        OutputStream out = new DataOutputStream(connection.getOutputStream());
+        InputStream in = new DataInputStream(connection.getInputStream());
+
         // first byte is version should be 5
-        int b = buffer.get();
+        int b = in.read();
         if (b != 5) {
             throw new IOException("Only SOCKS5 supported");
         }
 
         // second byte number of authentication methods supported
-        b = buffer.get();
+        b = in.read();
         int[] auth = new int[b];
         for (int i = 0; i < b; i++) {
-            auth[i] = buffer.get();
+            auth[i] = in.read();
         }
 
         int authMethod = -1;
@@ -168,11 +163,9 @@ public class ProxyConnectionManager {
         byte[] cmd = new byte[2];
         cmd[0] = (byte) 0x05;
         cmd[1] = (byte) 0x00;
-        buffer.clear();
-        buffer.put(cmd).flip();
-        connection.write(buffer);
+        out.write(cmd);
 
-        String responseDigest = processIncomingSocks5Message(connection, buffer);
+        String responseDigest = processIncomingSocks5Message(in);
         try {
             synchronized (connectionLock) {
                 ProxyTransfer transfer = connectionMap.get(responseDigest);
@@ -182,26 +175,21 @@ public class ProxyConnectionManager {
                     connectionMap.put(responseDigest, transfer);
                 }
                 else {
-                    transfer.setInputChannel(connection);
+                    transfer.setInputStream(connection.getInputStream());
                 }
             }
             cmd = createOutgoingSocks5Message(0, responseDigest);
-            buffer.clear();
-            buffer.put(cmd).flip();
-            connection.write(buffer);
+            out.write(cmd);
         }
         catch (UnauthorizedException eu) {
             cmd = createOutgoingSocks5Message(2, responseDigest);
-            buffer.clear();
-            buffer.put(cmd).flip();
-            connection.write(buffer);
+            out.write(cmd);
             throw new IOException("Illegal proxy transfer");
         }
     }
 
-    private ProxyTransfer createProxyTransfer(String transferDigest,
-                                              WritableByteChannel targetSocket)
-    {
+    private ProxyTransfer createProxyTransfer(String transferDigest, Socket targetSocket)
+            throws IOException {
         ProxyTransfer provider;
         try {
             Class c = ClassUtils.forName(className);
@@ -213,26 +201,32 @@ public class ProxyConnectionManager {
         }
 
         provider.setTransferDigest(transferDigest);
-        provider.setOutputChannel(targetSocket);
+        provider.setOutputStream(targetSocket.getOutputStream());
         return provider;
     }
 
-    private static String processIncomingSocks5Message(SocketChannel in, ByteBuffer buffer)
+    @SuppressWarnings({"ResultOfMethodCallIgnored"})
+    private static String processIncomingSocks5Message(InputStream in)
             throws IOException {
-        buffer.clear();
         // read the version and command
-        int read = in.read(buffer);
-
-        if (read < 5) {
+        byte[] cmd = new byte[5];
+        int read = in.read(cmd, 0, 5);
+        if (read != 5) {
             throw new IOException("Error reading Socks5 version and command");
         }
-        buffer.position(5);
 
         // read the digest
-        byte[] addr = new byte[buffer.get(4)];
-        buffer.get(addr, 0, addr.length);
+        byte[] addr = new byte[cmd[4]];
+        read = in.read(addr, 0, addr.length);
+        if (read != addr.length) {
+            throw new IOException("Error reading provided address");
+        }
+        String digest = new String(addr);
+
+        in.read();
+        in.read();
 
-        return new String(addr);
+        return digest;
     }
 
     private static byte[] createOutgoingSocks5Message(int cmd, String digest) {
@@ -344,9 +338,9 @@ public class ProxyConnectionManager {
             socketProcess.cancel(true);
             socketProcess = null;
         }
-        if (serverChannel != null) {
+        if (serverSocket != null) {
             try {
-                serverChannel.close();
+                serverSocket.close();
             }
             catch (IOException e) {
                 Log.warn("Error closing proxy listening socket", e);
@@ -360,7 +354,7 @@ public class ProxyConnectionManager {
         }
 
         public double sample() {
-            return (ProxyOutputChannel.amountTransfered.getAndSet(0) / 1000);
+            return (ProxyOutputStream.amountTransfered.getAndSet(0) / 1000);
         }
     }
 }
\ No newline at end of file

src/java/org/jivesoftware/wildfire/filetransfer/proxy/ProxyOutputChannel.java → src/java/org/jivesoftware/wildfire/filetransfer/proxy/ProxyOutputStream.java

@@ -8,33 +8,23 @@
  */
 package org.jivesoftware.wildfire.filetransfer.proxy;
 
+import java.io.OutputStream;
 import java.io.IOException;
+import java.io.DataOutputStream;
 import java.util.concurrent.atomic.AtomicLong;
-import java.nio.channels.WritableByteChannel;
-import java.nio.ByteBuffer;
 
 /**
  *  An output stream which tracks the amount of bytes transfered by proxy sockets.
  */
-public class ProxyOutputChannel implements WritableByteChannel {
+public class ProxyOutputStream extends DataOutputStream {
     static AtomicLong amountTransfered = new AtomicLong(0);
-    private WritableByteChannel channel;
 
-    public ProxyOutputChannel(WritableByteChannel channel) {
-        this.channel = channel;
+    public ProxyOutputStream(OutputStream out) {
+        super(out);
     }
 
-    public int write(ByteBuffer src) throws IOException {
-        int bytesWritten = channel.write(src);
-        amountTransfered.addAndGet(bytesWritten);
-        return bytesWritten;
-    }
-
-    public boolean isOpen() {
-        return channel.isOpen();
-    }
-
-    public void close() throws IOException {
-        channel.close();
+    public synchronized void write(byte b[], int off, int len) throws IOException {
+        super.write(b, off, len);
+        amountTransfered.addAndGet(len);
     }
 }