procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ActiveModeDTP.java, [...]: New files.

Browse source 
2005-02-19  Michael Koch  <konqueror@gmx.de>

	* gnu/java/net/protocol/ftp/ActiveModeDTP.java,
	gnu/java/net/protocol/ftp/BlockInputStream.java,
	gnu/java/net/protocol/ftp/BlockOutputStream.java,
	gnu/java/net/protocol/ftp/CompressedInputStream.java,
	gnu/java/net/protocol/ftp/CompressedOutputStream.java,
	gnu/java/net/protocol/ftp/DTPInputStream.java,
	gnu/java/net/protocol/ftp/DTP.java,
	gnu/java/net/protocol/ftp/DTPOutputStream.java,
	gnu/java/net/protocol/ftp/FTPConnection.java,
	gnu/java/net/protocol/ftp/FTPException.java,
	gnu/java/net/protocol/ftp/FTPResponse.java,
	gnu/java/net/protocol/ftp/FTPURLConnection.java,
	gnu/java/net/protocol/ftp/Handler.java,
	gnu/java/net/protocol/ftp/PassiveModeDTP.java,
	gnu/java/net/protocol/ftp/StreamInputStream.java,
	gnu/java/net/protocol/ftp/StreamOutputStream.java,
	gnu/java/net/CRLFInputStream.java,
	gnu/java/net/CRLFOutputStream.java,
	gnu/java/net/GetLocalHostAction.java,
	gnu/java/net/protocol/ftp/package.html: New files.
	* Makefile.am: Added new files.
	* Makefile.in: Regenerated.

From-SVN: r95272
This commit is contained in:
Michael Koch 2005-02-19 08:53:53 +00:00 • committed by Michael Koch
parent fc544c8180
commit 4aec6c476f
23 changed files with 4341 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

205
libjava/gnu/java/net/CRLFInputStream.java Normal file
View file

@ -0,0 +1,205 @@
/* CRLFInputStream.java --
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net;
import java.io.FilterInputStream;
import java.io.InputStream;
import java.io.IOException;
/**
* An input stream that filters out CR/LF pairs into LFs.
*
* @author Chris Burdess (dog@gnu.org)
*/
public class CRLFInputStream
extends FilterInputStream
{
/**
* The CR octet.
*/
public static final int CR = 13;
/**
* The LF octet.
*/
public static final int LF = 10;
/**
* Buffer.
*/
protected int buf = -1;
/**
* Buffer at time of mark.
*/
protected int markBuf = -1;
/**
* Constructs a CR/LF input stream connected to the specified input
* stream.
*/
public CRLFInputStream(InputStream in)
{
super(in);
}
/**
* Reads the next byte of data from this input stream.
* Returns -1 if the end of the stream has been reached.
* @exception IOException if an I/O error occurs
*/
public int read()
throws IOException
{
int c;
if (buf != -1)
{
c = buf;
buf = -1;
return c;
}
else
{
c = super.read();
if (c == CR)
{
buf = super.read();
if (buf == LF)
{
c = buf;
buf = -1;
}
}
}
return c;
}
/**
* Reads up to b.length bytes of data from this input stream into
* an array of bytes.
* Returns -1 if the end of the stream has been reached.
* @exception IOException if an I/O error occurs
*/
public int read(byte[] b)
throws IOException
{
return read(b, 0, b.length);
}
/**
* Reads up to len bytes of data from this input stream into an
* array of bytes, starting at the specified offset.
* Returns -1 if the end of the stream has been reached.
* @exception IOException if an I/O error occurs
*/
public int read(byte[] b, int off, int len)
throws IOException
{
int shift = 0;
if (buf != -1)
{
// Push buf onto start of byte array
b[off] = (byte) buf;
off++;
len--;
buf = -1;
shift++;
}
int l = super.read(b, off, len);
l = removeCRLF(b, off - shift, l);
return l;
}
/**
* Indicates whether this stream supports the mark and reset methods.
*/
public boolean markSupported()
{
return in.markSupported();
}
/**
* Marks the current position in this stream.
*/
public void mark(int readlimit)
{
in.mark(readlimit);
markBuf = buf;
}
/**
* Repositions this stream to the position at the time the mark method was
* called.
*/
public void reset()
throws IOException
{
in.reset();
buf = markBuf;
}
private int removeCRLF(byte[] b, int off, int len)
{
int end = off + len;
for (int i = off; i < end; i++)
{
if (b[i] == CR)
{
if (i + 1 == end)
{
// This is the last byte, impossible to determine whether CRLF
buf = CR;
len--;
}
else if (b[i + 1] == LF)
{
// Shift left
end--;
for (int j = i; j < end; j++)
{
b[j] = b[j + 1];
}
len--;
end = off + len;
}
}
}
return len;
}
}

183
libjava/gnu/java/net/CRLFOutputStream.java Normal file
View file

@ -0,0 +1,183 @@
/* CRLFOutputStream.java --
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
/**
* An output stream that filters LFs into CR/LF pairs.
*
* @author Chris Burdess (dog@gnu.org)
*/
public class CRLFOutputStream
extends FilterOutputStream
{
static final String US_ASCII = "US-ASCII";
/**
* The CR octet.
*/
public static final int CR = 13;
/**
* The LF octet.
*/
public static final int LF = 10;
/**
* The CR/LF pair.
*/
public static final byte[] CRLF = { CR, LF };
/**
* The last byte read.
*/
protected int last;
/**
* Constructs a CR/LF output stream connected to the specified output stream.
*/
public CRLFOutputStream(OutputStream out)
{
super(out);
last = -1;
}
/**
* Writes a character to the underlying stream.
* @exception IOException if an I/O error occurred
*/
public void write(int ch) throws IOException
{
if (ch == CR)
{
out.write(CRLF);
}
else if (ch == LF)
{
if (last != CR)
{
out.write(CRLF);
}
}
else
{
out.write(ch);
}
last = ch;
}
/**
* Writes a byte array to the underlying stream.
* @exception IOException if an I/O error occurred
*/
public void write(byte[] b)
throws IOException
{
write(b, 0, b.length);
}
/**
* Writes a portion of a byte array to the underlying stream.
* @exception IOException if an I/O error occurred
*/
public void write(byte[] b, int off, int len)
throws IOException
{
int d = off;
len += off;
for (int i = off; i < len; i++)
{
switch (b[i])
{
case CR:
out.write (b, d, i - d);
out.write (CRLF, 0, 2);
d = i + 1;
break;
case LF:
if (last != CR)
{
out.write (b, d, i - d);
out.write (CRLF, 0, 2);
}
d = i + 1;
break;
}
last = b[i];
}
if (len - d > 0)
{
out.write (b, d, len - d);
}
}
/**
* Writes the specified ASCII string to the underlying stream.
* @exception IOException if an I/O error occurred
*/
public void write(String text)
throws IOException
{
try
{
byte[] bytes = text.getBytes(US_ASCII);
write(bytes, 0, bytes.length);
}
catch (UnsupportedEncodingException e)
{
throw new IOException("The US-ASCII encoding is not supported " +
"on this system");
}
}
/**
* Writes a newline to the underlying stream.
* @exception IOException if an I/O error occurred
*/
public void writeln()
throws IOException
{
out.write(CRLF, 0, 2);
}
}

65
libjava/gnu/java/net/GetLocalHostAction.java Normal file
View file

@ -0,0 +1,65 @@
/* GetLocalHostAction.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.security.PrivilegedAction;
/**
* Privileged action to retrieve the local host InetAddress.
*
* @author Chris Burdess (dog@gnu.org)
*/
public class GetLocalHostAction
implements PrivilegedAction
{
public Object run()
{
try
{
return InetAddress.getLocalHost();
}
catch (UnknownHostException e)
{
return null;
}
}
}

251
libjava/gnu/java/net/protocol/ftp/ActiveModeDTP.java Normal file
View file

@ -0,0 +1,251 @@
/* ActiveModeDTP.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
* An active mode FTP data transfer process.
* This starts a server on the specified port listening for a data
* connection. It converts the socket input into a file stream for reading.
*
* @author Chris Burdess (dog@gnu.org)
*/
final class ActiveModeDTP
implements DTP, Runnable
{
ServerSocket server;
Socket socket;
DTPInputStream in;
DTPOutputStream out;
boolean completed;
boolean inProgress;
int transferMode;
IOException exception;
Thread acceptThread;
int connectionTimeout;
ActiveModeDTP(InetAddress localhost, int port,
int connectionTimeout, int timeout)
throws IOException
{
completed = false;
inProgress = false;
server = new ServerSocket(port, 1, localhost);
if (timeout > 0)
{
server.setSoTimeout(timeout);
}
if (connectionTimeout <= 0)
{
connectionTimeout = 20000;
}
this.connectionTimeout = connectionTimeout;
acceptThread = new Thread(this, "ActiveModeDTP");
acceptThread.start();
}
/**
* Start listening.
*/
public void run()
{
try
{
socket = server.accept();
//System.err.println("Accepted connection from "+socket.getInetAddress()+":"+socket.getPort());
}
catch (IOException e)
{
exception = e;
}
}
/**
* Waits until a client has connected.
*/
public void waitFor()
throws IOException
{
try
{
acceptThread.join(connectionTimeout);
}
catch (InterruptedException e)
{
}
if (exception != null)
{
throw exception;
}
if (socket == null)
{
server.close();
throw new IOException("client did not connect before timeout");
}
acceptThread = null;
}
/**
* Returns an input stream from which a remote file can be read.
*/
public InputStream getInputStream()
throws IOException
{
if (inProgress)
{
throw new IOException("Transfer in progress");
}
if (acceptThread != null)
{
waitFor();
}
switch (transferMode)
{
case FTPConnection.MODE_STREAM:
in = new StreamInputStream(this, socket.getInputStream());
break;
case FTPConnection.MODE_BLOCK:
in = new BlockInputStream(this, socket.getInputStream());
break;
case FTPConnection.MODE_COMPRESSED:
in = new CompressedInputStream(this, socket.getInputStream());
break;
default:
throw new IllegalStateException("invalid transfer mode");
}
in.setTransferComplete(false);
return in;
}
/**
* Returns an output stream to which a local file can be written for
* upload.
*/
public OutputStream getOutputStream() throws IOException
{
if (inProgress)
{
throw new IOException("Transfer in progress");
}
if (acceptThread != null)
{
waitFor();
}
switch (transferMode)
{
case FTPConnection.MODE_STREAM:
out = new StreamOutputStream(this, socket.getOutputStream());
break;
case FTPConnection.MODE_BLOCK:
out = new BlockOutputStream(this, socket.getOutputStream());
break;
case FTPConnection.MODE_COMPRESSED:
out = new CompressedOutputStream(this, socket.getOutputStream());
break;
default:
throw new IllegalStateException("invalid transfer mode");
}
out.setTransferComplete(false);
return out;
}
public void setTransferMode(int mode)
{
transferMode = mode;
}
public void complete()
{
completed = true;
if (!inProgress)
{
transferComplete();
}
}
public boolean abort()
{
completed = true;
transferComplete();
return inProgress;
}
public void transferComplete()
{
if (socket == null)
{
return;
}
if (in != null)
{
in.setTransferComplete(true);
}
if (out != null)
{
out.setTransferComplete(true);
}
completed = completed || (transferMode == FTPConnection.MODE_STREAM);
if (completed && socket != null)
{
try
{
socket.close();
}
catch (IOException e)
{
}
try
{
server.close();
}
catch (IOException e)
{
}
}
}
}

150
libjava/gnu/java/net/protocol/ftp/BlockInputStream.java Normal file
View file

@ -0,0 +1,150 @@
/* BlockInputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.InputStream;
import java.io.IOException;
/**
* A DTP input stream that implements the FTP block transfer mode.
*
* @author Chris Burdess (dog@gnu.org)
*/
class BlockInputStream
extends DTPInputStream
{
static final int EOF = 64;
int descriptor;
int max = -1;
int count = -1;
BlockInputStream(DTP dtp, InputStream in)
{
super(dtp, in);
}
public int read()
throws IOException
{
if (transferComplete)
{
return -1;
}
if (count == -1)
{
readHeader();
}
if (max < 1)
{
close();
return -1;
}
int c = in.read();
if (c == -1)
{
dtp.transferComplete();
}
count++;
if (count >= max)
{
count = -1;
if (descriptor == EOF)
{
close();
}
}
return c;
}
public int read(byte[] buf)
throws IOException
{
return read(buf, 0, buf.length);
}
public int read(byte[] buf, int off, int len)
throws IOException
{
if (transferComplete)
{
return -1;
}
if (count == -1)
{
readHeader();
}
if (max < 1)
{
close();
return -1;
}
int l = in.read(buf, off, len);
if (l == -1)
{
dtp.transferComplete();
}
count += l;
if (count >= max)
{
count = -1;
if (descriptor == EOF)
{
close();
}
}
return l;
}
/**
* Reads the block header.
*/
void readHeader()
throws IOException
{
descriptor = in.read();
int max_hi = in.read();
int max_lo = in.read();
max = (max_hi << 8) | max_lo;
count = 0;
}
}

111
libjava/gnu/java/net/protocol/ftp/BlockOutputStream.java Normal file
View file

@ -0,0 +1,111 @@
/* BlockOutputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.IOException;
import java.io.OutputStream;
/**
* A DTP output stream that implements the FTP block transfer mode.
*
* @author Chris Burdess (dog@gnu.org)
*/
class BlockOutputStream
extends DTPOutputStream
{
static final byte RECORD = -128; // 0x80
static final byte EOF = 64; // 0x40
BlockOutputStream(DTP dtp, OutputStream out)
{
super(dtp, out);
}
public void write(int c)
throws IOException
{
if (transferComplete)
{
return;
}
byte[] buf = new byte[]
{
RECORD, /* record descriptor */
0x00, 0x01, /* one byte */
(byte) c /* the byte */
};
out.write(buf, 0, 4);
}
public void write(byte[] b)
throws IOException
{
write(b, 0, b.length);
}
public void write(byte[] b, int off, int len)
throws IOException
{
if (transferComplete)
{
return;
}
byte[] buf = new byte[len + 3];
buf[0] = RECORD; /* record descriptor */
buf[1] = (byte) ((len & 0x00ff) >> 8); /* high byte of bytecount */
buf[2] = (byte) (len & 0xff00); /* low byte of bytecount */
System.arraycopy(b, off, buf, 3, len);
out.write(buf, 0, len);
}
public void close()
throws IOException
{
byte[] buf = new byte[]
{
EOF, /* eof descriptor */
0x00, 0x00 /* no bytes */
};
out.write(buf, 0, 3);
super.close();
}
}

215
libjava/gnu/java/net/protocol/ftp/CompressedInputStream.java Normal file
View file

@ -0,0 +1,215 @@
/* CompressedInputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.InputStream;
import java.io.IOException;
import java.net.ProtocolException;
/**
* A DTP input stream that implements the FTP compressed transfer mode.
*
* @author Chris Burdess (dog@gnu.org)
*/
class CompressedInputStream
extends DTPInputStream
{
static final int EOF = 64;
static final int RAW = 0x00;
static final int COMPRESSED = 0x80;
static final int FILLER = 0xc0;
int descriptor;
int max = -1;
int count = -1;
int state = RAW; // RAW | STATE | FILLER
int rep; // the compressed byte
int n = 0; // the number of compressed or raw bytes
CompressedInputStream(DTP dtp, InputStream in)
{
super(dtp, in);
}
public int read()
throws IOException
{
if (transferComplete)
{
return -1;
}
if (count == -1)
{
readHeader();
}
if (max < 1)
{
close();
return -1;
}
if (n > 0 && (state == COMPRESSED || state == FILLER))
{
n--;
return rep;
}
int c = in.read();
if (c == -1)
{
close();
}
count++;
if (count >= max)
{
count = -1;
if (descriptor == EOF)
{
close();
}
}
if (c == -1)
{
return c;
}
while (n == 0) // read code header
{
state = (c & 0xc0);
n = (c & 0x3f);
c = in.read();
if (c == -1)
{
return -1;
}
}
switch (state)
{
case RAW:
break;
case COMPRESSED:
case FILLER:
rep = c;
break;
default:
throw new ProtocolException("Illegal state: " + state);
}
n--;
return c;
}
public int read(byte[] buf)
throws IOException
{
return read(buf, 0, buf.length);
}
public int read(byte[] buf, int off, int len)
throws IOException
{
if (transferComplete)
{
return -1;
}
if (count == -1)
{
readHeader();
}
if (max < 1)
{
close();
return -1;
}
// TODO improve performance
for (int i = off; i < len; i++)
{
int c = read();
if (c == -1)
{
close();
return i;
}
buf[i] = (byte) c;
}
return len;
/*
int l = in.read (buf, off, len);
if (l==-1)
{
close ();
}
count += l;
if (count>=max)
{
count = -1;
if (descriptor==EOF)
{
close ();
}
}
return l;
*/
}
/**
* Reads the block header.
*/
void readHeader()
throws IOException
{
descriptor = in.read();
int max_hi = in.read();
int max_lo = in.read();
max = (max_hi << 8) | max_lo;
count = 0;
}
/**
* Reads the code header.
*/
void readCodeHeader()
throws IOException
{
int code = in.read();
state = (code & 0xc0);
n = (code & 0x3f);
}
}

228
libjava/gnu/java/net/protocol/ftp/CompressedOutputStream.java Normal file
View file

@ -0,0 +1,228 @@
/* CompressedOutputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.IOException;
import java.io.OutputStream;
/**
* A DTP output stream that implements the FTP compressed transfer mode.
*
* @author Chris Burdess (dog@gnu.org)
*/
class CompressedOutputStream
extends DTPOutputStream
{
static final byte RECORD = -128; // 0x80
static final byte EOF = 64; // 0x40
CompressedOutputStream(DTP dtp, OutputStream out)
{
super(dtp, out);
}
/**
* Just one byte cannot be compressed.
* It takes 5 bytes to transmit - hardly very compressed!
*/
public void write(int c)
throws IOException
{
if (transferComplete)
{
return;
}
byte[] buf = new byte[]
{
RECORD, /* record descriptor */
0x00, 0x01, /* one byte */
0x01, /* one uncompressed byte */
(byte) c /* the byte */
};
out.write(buf, 0, 5);
}
public void write(byte[] b)
throws IOException
{
write(b, 0, b.length);
}
/**
* The larger len is, the better.
*/
public void write(byte[] b, int off, int len)
throws IOException
{
if (transferComplete)
{
return;
}
byte[] buf = compress(b, off, len);
len = buf.length;
buf[0] = RECORD; /* record descriptor */
buf[1] = (byte) ((len & 0x00ff) >> 8); /* high byte of bytecount */
buf[2] = (byte) (len & 0xff00); /* low byte of bytecount */
out.write(buf, 0, len);
}
/**
* Returns the compressed form of the given byte array.
* The first 3 bytes are left free for header information.
*/
byte[] compress(byte[] b, int off, int len)
{
byte[] buf = new byte[len];
byte last = 0;
int pos = 0, raw_count = 0, rep_count = 1;
for (int i = off; i < len; i++)
{
byte c = b[i];
if (i > off && c == last) // compress
{
if (raw_count > 0) // flush raw bytes to buf
{
// need to add raw_count+1 bytes
if (pos + (raw_count + 1) > buf.length)
{
buf = realloc(buf, len);
}
pos = flush_raw(buf, pos, b, (i - raw_count) - 1,
raw_count);
raw_count = 0;
}
rep_count++; // keep looking for same byte
}
else
{
if (rep_count > 1) // flush compressed bytes to buf
{
// need to add 2 bytes
if (pos + 2 > buf.length)
{
buf = realloc(buf, len);
}
pos = flush_compressed(buf, pos, rep_count, last);
rep_count = 1;
}
raw_count++; // keep looking for raw bytes
}
if (rep_count == 127) // flush compressed bytes
{
// need to add 2 bytes
if (pos + 2 > buf.length)
{
buf = realloc(buf, len);
}
pos = flush_compressed(buf, pos, rep_count, last);
rep_count = 1;
}
if (raw_count == 127) // flush raw bytes
{
// need to add raw_count+1 bytes
if (pos + (raw_count + 1) > buf.length)
{
buf = realloc(buf, len);
}
pos = flush_raw(buf, pos, b, (i - raw_count), raw_count);
raw_count = 0;
}
last = c;
}
if (rep_count > 1) // flush compressed bytes
{
// need to add 2 bytes
if (pos + 2 > buf.length)
{
buf = realloc(buf, len);
}
pos = flush_compressed(buf, pos, rep_count, last);
rep_count = 1;
}
if (raw_count > 0) // flush raw bytes
{
// need to add raw_count+1 bytes
if (pos + (raw_count + 1) > buf.length)
{
buf = realloc(buf, len);
}
pos = flush_raw(buf, pos, b, (len - raw_count), raw_count);
raw_count = 0;
}
byte[] ret = new byte[pos + 3];
System.arraycopy(buf, 0, ret, 3, pos);
return ret;
}
int flush_compressed(byte[] buf, int pos, int count, byte c)
{
buf[pos++] = (byte) (0x80 | count);
buf[pos++] = c;
return pos;
}
int flush_raw(byte[] buf, int pos, byte[] src, int off, int len)
{
buf[pos++] = (byte) len;
System.arraycopy(src, off, buf, pos, len);
return pos + len;
}
byte[] realloc(byte[] buf, int len)
{
byte[] ret = new byte[buf.length + len];
System.arraycopy(buf, 0, ret, 0, buf.length);
return ret;
}
public void close()
throws IOException
{
byte[] buf = new byte[]
{
EOF, /* eof descriptor */
0x00, 0x00 /* no bytes */
};
out.write(buf, 0, 3);
out.close();
}
}

92
libjava/gnu/java/net/protocol/ftp/DTP.java Normal file
View file

@ -0,0 +1,92 @@
/* DTP.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* An FTP data transfer process.
*
* @author Chris Burdess (dog@gnu.org)
*/
interface DTP
{
/**
* Returns an input stream from which a remote file can be read.
*/
InputStream getInputStream()
throws IOException;
/**
* Returns an output stream to which a local file can be written for
* upload.
*/
OutputStream getOutputStream()
throws IOException;
/**
* Sets the transfer mode to be used with this DTP.
*/
void setTransferMode(int mode);
/**
* Marks this DTP completed.
* When the current transfer has finished, any resources will be released.
*/
void complete();
/**
* Aborts any current transfer and releases all resources held by this
* DTP.
* @return true if a transfer was interrupted, false otherwise
*/
boolean abort();
/**
* Used to notify the DTP that its current transfer is complete.
* This occurs either when end-of-stream is reached or a 226 response is
* received.
*/
void transferComplete();
}

88
libjava/gnu/java/net/protocol/ftp/DTPInputStream.java Normal file
View file

@ -0,0 +1,88 @@
/* DTPInputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.FilterInputStream;
import java.io.InputStream;
import java.io.IOException;
/**
* An input stream that notifies a DTP on completion.
*
* @author Chris Burdess (dog@gnu.org)
*/
abstract class DTPInputStream
extends FilterInputStream
{
DTP dtp;
boolean transferComplete;
/**
* Constructor.
* @param dtp the controlling data transfer process
* @param in the underlying socket stream
*/
DTPInputStream (DTP dtp, InputStream in)
{
super(in);
this.dtp = dtp;
transferComplete = false;
}
/**
* Marks this input stream complete.
* This is called by the DTP.
*/
void setTransferComplete(boolean flag)
{
transferComplete = flag;
}
/**
* Notifies the controlling DTP that this stream has completed transfer.
*/
public void close()
throws IOException
{
dtp.transferComplete();
}
}

85
libjava/gnu/java/net/protocol/ftp/DTPOutputStream.java Normal file
View file

@ -0,0 +1,85 @@
/* DTPOutputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* An output stream that notifies a DTP on end of stream.
*
* @author Chris Burdess (dog@gnu.org)
*/
abstract class DTPOutputStream extends FilterOutputStream
{
DTP dtp;
boolean transferComplete;
/**
* Constructor.
* @param dtp the controlling data transfer process
* @param out the socket output stream
*/
DTPOutputStream (DTP dtp, OutputStream out)
{
super (out);
this.dtp = dtp;
transferComplete = false;
}
/**
* Tells this stream whether transfer has completed or not.
* @param flag true if the process has completed, false otherwise
*/
void setTransferComplete (boolean flag)
{
transferComplete = flag;
}
/**
* Notifies the controlling DTP that this stream has been terminated.
*/
public void close () throws IOException
{
dtp.transferComplete ();
}
}

1348
libjava/gnu/java/net/protocol/ftp/FTPConnection.java Normal file
View file

File diff suppressed because it is too large Load diff

76
libjava/gnu/java/net/protocol/ftp/FTPException.java Normal file
View file

@ -0,0 +1,76 @@
/* FTPException.java --
Copyright (C) 2003. 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.IOException;
/**
* An FTP control exception.
*
* @author Chris Burdess (dog@gnu.org)
*/
public class FTPException
extends IOException
{
/**
* The response that provoked this exception.
*/
protected final FTPResponse response;
/**
* Constructs a new FTP exception.
* @param response the response that provoked this exception
*/
public FTPException(FTPResponse response)
{
super(response.getMessage());
this.response = response;
}
/**
* Returns the response that provoked this exception.
*/
public FTPResponse getResponse()
{
return response;
}
}

112
libjava/gnu/java/net/protocol/ftp/FTPResponse.java Normal file
View file

@ -0,0 +1,112 @@
/* FTPResponse.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
/**
* An FTP control response.
*
* @author Chris Burdess (dog@gnu.org)
*/
public final class FTPResponse
{
/**
* The 3-digit status code.
*/
protected final int code;
/**
* The human-readable message.
*/
protected final String message;
/**
* Multiline data, if present.
*/
protected final String data;
/**
* Constructs a new FTP response.
* @param code the status code
* @param message the message
*/
public FTPResponse(int code, String message)
{
this(code, message, null);
}
/**
* Constructs a new multiline FTP response.
* @param code the status code
* @param message the message
* @param data multiline data
*/
public FTPResponse(int code, String message, String data)
{
this.code = code;
this.message = message;
this.data = data;
}
/**
* Returns the 3-digit status code.
*/
public int getCode()
{
return code;
}
/**
* Returns the human-readable message.
*/
public String getMessage()
{
return message;
}
/**
* Returns the multiline data, or null if there was no such data.
*/
public String getData()
{
return data;
}
}

398
libjava/gnu/java/net/protocol/ftp/FTPURLConnection.java Normal file
View file

@ -0,0 +1,398 @@
/* FTPURLConnection.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import gnu.java.net.GetLocalHostAction;
import gnu.java.security.action.GetPropertyAction;
import java.io.FileNotFoundException;
import java.io.FilterInputStream;
import java.io.FilterOutputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.URL;
import java.net.URLConnection;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.Map;
/**
* An FTP URL connection.
*
* @author Chris Burdess (dog@gnu.org)
*/
public class FTPURLConnection
extends URLConnection
{
/**
* The connection managing the protocol exchange.
*/
protected FTPConnection connection;
protected boolean passive;
protected int representationType;
protected int fileStructure;
protected int transferMode;
/**
* Constructs an FTP connection to the specified URL.
* @param url the URL
*/
public FTPURLConnection(URL url)
{
super(url);
passive = true;
representationType = FTPConnection.TYPE_BINARY;
fileStructure = -1;
transferMode = -1;
}
/**
* Establishes the connection.
*/
public void connect()
throws IOException
{
if (connected)
{
return;
}
String host = url.getHost();
int port = url.getPort();
String username = url.getUserInfo();
String password = null;
if (username != null)
{
int ci = username.indexOf(':');
if (ci != -1)
{
password = username.substring(ci + 1);
username = username.substring(0, ci);
}
}
else
{
username = "anonymous";
PrivilegedAction a = new GetPropertyAction("user.name");
String systemUsername =(String) AccessController.doPrivileged(a);
a = new GetLocalHostAction();
InetAddress localhost =(InetAddress) AccessController.doPrivileged(a);
password = systemUsername + "@" +
((localhost == null) ? "localhost" : localhost.getHostName());
}
connection = new FTPConnection(host, port);
if (!connection.authenticate(username, password))
{
throw new SecurityException("Authentication failed");
}
connection.setPassive(passive);
if (representationType != -1)
{
connection.setRepresentationType(representationType);
}
if (fileStructure != -1)
{
connection.setFileStructure(fileStructure);
}
if (transferMode != -1)
{
connection.setTransferMode(transferMode);
}
}
/**
* This connection supports doInput.
*/
public void setDoInput(boolean doinput)
{
doInput = doinput;
}
/**
* This connection supports doOutput.
*/
public void setDoOutput(boolean dooutput)
{
doOutput = dooutput;
}
/**
* Returns an input stream that reads from this open connection.
*/
public InputStream getInputStream()
throws IOException
{
if (!connected)
{
connect();
}
String path = url.getPath();
String filename = null;
int lsi = path.lastIndexOf('/');
if (lsi != -1)
{
filename = path.substring(lsi + 1);
path = path.substring(0, lsi);
if (!connection.changeWorkingDirectory(path))
{
throw new FileNotFoundException(path);
}
}
if (filename != null && filename.length() > 0)
{
return this.new ClosingInputStream(connection.retrieve(filename));
}
else
{
return this.new ClosingInputStream(connection.list(null));
}
}
/**
* Returns an output stream that writes to this connection.
*/
public OutputStream getOutputStream()
throws IOException
{
if (!connected)
{
connect();
}
String dir = url.getPath();
String filename = url.getFile();
if (!connection.changeWorkingDirectory(dir))
{
throw new FileNotFoundException(dir);
}
if (filename != null)
{
return this.new ClosingOutputStream(connection.store(filename));
}
else
{
throw new FileNotFoundException(filename);
}
}
public String getRequestProperty(String key)
{
if ("passive".equals(key))
{
return Boolean.toString(passive);
}
else if ("representationType".equals(key))
{
switch (representationType)
{
case FTPConnection.TYPE_ASCII:
return "ASCII";
case FTPConnection.TYPE_EBCDIC:
return "EBCDIC";
case FTPConnection.TYPE_BINARY:
return "BINARY";
}
}
else if ("fileStructure".equals(key))
{
switch (fileStructure)
{
case FTPConnection.STRUCTURE_FILE:
return "FILE";
case FTPConnection.STRUCTURE_RECORD:
return "RECORD";
case FTPConnection.STRUCTURE_PAGE:
return "PAGE";
}
}
else if ("transferMode".equals(key))
{
switch (transferMode)
{
case FTPConnection.MODE_STREAM:
return "STREAM";
case FTPConnection.MODE_BLOCK:
return "BLOCK";
case FTPConnection.MODE_COMPRESSED:
return "COMPRESSED";
}
}
return null;
}
public Map getRequestProperties()
{
Map map = new HashMap();
addRequestPropertyValue(map, "passive");
addRequestPropertyValue(map, "representationType");
addRequestPropertyValue(map, "fileStructure");
addRequestPropertyValue(map, "transferMode");
return map;
}
private void addRequestPropertyValue(Map map, String key)
{
String value = getRequestProperty(key);
map.put(key, value);
}
public void setRequestProperty(String key, String value)
{
if (connected)
{
throw new IllegalStateException();
}
if ("passive".equals(key))
{
passive = Boolean.valueOf(value).booleanValue();
}
else if ("representationType".equals(key))
{
if ("A".equalsIgnoreCase(value) ||
"ASCII".equalsIgnoreCase(value))
{
representationType = FTPConnection.TYPE_ASCII;
}
else if ("E".equalsIgnoreCase(value) ||
"EBCDIC".equalsIgnoreCase(value))
{
representationType = FTPConnection.TYPE_EBCDIC;
}
else if ("I".equalsIgnoreCase(value) ||
"BINARY".equalsIgnoreCase(value))
{
representationType = FTPConnection.TYPE_BINARY;
}
else
{
throw new IllegalArgumentException(value);
}
}
else if ("fileStructure".equals(key))
{
if ("F".equalsIgnoreCase(value) ||
"FILE".equalsIgnoreCase(value))
{
fileStructure = FTPConnection.STRUCTURE_FILE;
}
else if ("R".equalsIgnoreCase(value) ||
"RECORD".equalsIgnoreCase(value))
{
fileStructure = FTPConnection.STRUCTURE_RECORD;
}
else if ("P".equalsIgnoreCase(value) ||
"PAGE".equalsIgnoreCase(value))
{
fileStructure = FTPConnection.STRUCTURE_PAGE;
}
else
{
throw new IllegalArgumentException(value);
}
}
else if ("transferMode".equals(key))
{
if ("S".equalsIgnoreCase(value) ||
"STREAM".equalsIgnoreCase(value))
{
transferMode = FTPConnection.MODE_STREAM;
}
else if ("B".equalsIgnoreCase(value) ||
"BLOCK".equalsIgnoreCase(value))
{
transferMode = FTPConnection.MODE_BLOCK;
}
else if ("C".equalsIgnoreCase(value) ||
"COMPRESSED".equalsIgnoreCase(value))
{
transferMode = FTPConnection.MODE_COMPRESSED;
}
else
{
throw new IllegalArgumentException(value);
}
}
}
public void addRequestProperty(String key, String value)
{
setRequestProperty(key, value);
}
class ClosingInputStream
extends FilterInputStream
{
ClosingInputStream(InputStream in)
{
super(in);
}
public void close()
throws IOException
{
super.close();
connection.logout();
}
}
class ClosingOutputStream
extends FilterOutputStream
{
ClosingOutputStream(OutputStream out)
{
super(out);
}
public void close()
throws IOException
{
super.close();
connection.logout();
}
}
}

70
libjava/gnu/java/net/protocol/ftp/Handler.java Normal file
View file

@ -0,0 +1,70 @@
/* Handler.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
/**
* An FTP URL stream handler.
*
* @author Chris Burdess (dog@gnu.org)
*/
public class Handler
extends URLStreamHandler
{
protected int getDefaultPort()
{
return FTPConnection.FTP_PORT;
}
/**
* Returns an FTPURLConnection for the given URL.
*/
public URLConnection openConnection(URL url)
throws IOException
{
return new FTPURLConnection(url);
}
}

201
libjava/gnu/java/net/protocol/ftp/PassiveModeDTP.java Normal file
View file

@ -0,0 +1,201 @@
/* PassiveModeDTP.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
/**
* A passive mode FTP data transfer process.
* This connects to the host specified and proxies the resulting socket's
* input and output streams.
*
* @author Chris Burdess (dog@gnu.org)
*/
final class PassiveModeDTP
implements DTP
{
final String address;
final int port;
Socket socket;
DTPInputStream in;
DTPOutputStream out;
boolean completed;
boolean inProgress;
int transferMode;
PassiveModeDTP(String address, int port, InetAddress localhost,
int connectionTimeout, int timeout)
throws IOException
{
this.address = address;
this.port = port;
completed = false;
inProgress = false;
socket = new Socket();
InetSocketAddress remote = new InetSocketAddress(address, port);
InetSocketAddress local = new InetSocketAddress(localhost, port + 1);
socket.bind(local);
if (connectionTimeout > 0)
{
socket.connect(remote, connectionTimeout);
}
else
{
socket.connect(remote);
}
if (timeout > 0)
{
socket.setSoTimeout(timeout);
}
}
/**
* Returns an input stream from which a remote file can be read.
*/
public InputStream getInputStream()
throws IOException
{
if (inProgress)
{
throw new IOException("Transfer in progress");
}
switch (transferMode)
{
case FTPConnection.MODE_STREAM:
in = new StreamInputStream(this, socket.getInputStream());
break;
case FTPConnection.MODE_BLOCK:
in = new BlockInputStream(this, socket.getInputStream());
break;
case FTPConnection.MODE_COMPRESSED:
in = new CompressedInputStream(this, socket.getInputStream());
break;
default:
throw new IllegalStateException("Invalid transfer mode");
}
in.setTransferComplete(false);
return in;
}
/**
* Returns an output stream to which a local file can be written for
* upload.
*/
public OutputStream getOutputStream()
throws IOException
{
if (inProgress)
{
throw new IOException("Transfer in progress");
}
switch (transferMode)
{
case FTPConnection.MODE_STREAM:
out = new StreamOutputStream(this, socket.getOutputStream());
break;
case FTPConnection.MODE_BLOCK:
out = new BlockOutputStream(this, socket.getOutputStream());
break;
case FTPConnection.MODE_COMPRESSED:
out = new CompressedOutputStream(this, socket.getOutputStream());
break;
default:
throw new IllegalStateException("Invalid transfer mode");
}
out.setTransferComplete(false);
return out;
}
public void setTransferMode(int mode)
{
transferMode = mode;
}
public void complete()
{
completed = true;
if (!inProgress)
{
transferComplete();
}
}
public boolean abort()
{
completed = true;
transferComplete();
return inProgress;
}
/*
* Called by DTPInputStream or DTPOutputStream when end of
* stream is reached.
*/
public void transferComplete()
{
if (in != null)
{
in.setTransferComplete(true);
}
if (out != null)
{
out.setTransferComplete(true);
}
inProgress = false;
completed = completed ||(transferMode == FTPConnection.MODE_STREAM);
if (completed && socket != null)
{
try
{
socket.close();
}
catch (IOException e)
{
}
}
}
}

95
libjava/gnu/java/net/protocol/ftp/StreamInputStream.java Normal file
View file

@ -0,0 +1,95 @@
/* StreamInputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.InputStream;
import java.io.IOException;
/**
* A DTP input stream that implements the FTP stream data transfer mode.
*
* @author Chris Burdess (dog@gnu.org)
*/
class StreamInputStream
extends DTPInputStream
{
StreamInputStream(DTP dtp, InputStream in)
{
super(dtp, in);
}
public int read()
throws IOException
{
if (transferComplete)
{
return -1;
}
int c = in.read();
if (c == -1)
{
close();
}
return c;
}
public int read(byte[] buf)
throws IOException
{
return read(buf, 0, buf.length);
}
public int read(byte[] buf, int off, int len)
throws IOException
{
if (transferComplete)
{
return -1;
}
int l = in.read(buf, off, len);
if (l == -1)
{
close();
}
return l;
}
}

85
libjava/gnu/java/net/protocol/ftp/StreamOutputStream.java Normal file
View file

@ -0,0 +1,85 @@
/* StreamOutputStream.java --
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.net.protocol.ftp;
import java.io.IOException;
import java.io.OutputStream;
/**
* A DTP output stream that implements the FTP stream transfer mode.
*
* @author Chris Burdess (dog@gnu.org)
*/
class StreamOutputStream
extends DTPOutputStream
{
StreamOutputStream(DTP dtp, OutputStream out)
{
super(dtp, out);
}
public void write(int c)
throws IOException
{
if (transferComplete)
{
return;
}
out.write(c);
}
public void write(byte[] b)
throws IOException
{
write(b, 0, b.length);
}
public void write(byte[] b, int off, int len)
throws IOException
{
if (transferComplete)
{
return;
}
out.write(b, off, len);
}
}

60
libjava/gnu/java/net/protocol/ftp/package.html Normal file
View file

@ -0,0 +1,60 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<!-- package.html - describes classes in gnu.java.net.protocol.ftp package.
Copyright (C) 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. -->
<html>
<head><title>GNU Classpath - gnu.java.net.protocol.ftp</title></head>
<body>
<p>
This package contains an FTP client. It can handle both active and passive
mode connections and the various transfer modes and representation types.
</p>
<p>
Interaction with the server is via a simple stream interface. Only one
concurrent stream (input or output) is supported.
</p>
<p>
The control connection to the server can be protected using TLS
(the starttls method).
</p>
</body>
</html>