Package org.globus.ftp.vanilla

# Class FTPControlChannel

java.lang.Object
org.globus.ftp.vanilla.BasicClientControlChannel
org.globus.ftp.vanilla.FTPControlChannel

Direct Known Subclasses:
  `GridFTPControlChannel`

public class FTPControlChannel extends BasicClientControlChannel

Represents FTP Protocol Interpreter. Encapsulates control channel communication.

## Field Summary

Fields
Modifier and Type
Field
Description
`static final String`
`CRLF`
`protected BufferedReader`
`ftpIn`
`protected OutputStream`
`ftpOut`
`protected boolean`
`hasBeenOpened`
`protected String`
`host`
`protected int`
`port`
`protected InputStream`
`rawFtpIn`
`protected Socket`
`socket`

## Constructor Summary

Constructors
Constructor
Description
`FTPControlChannel(InputStream in, OutputStream out)`
Using this constructor, you can initialize an instance that does not talk directly to the socket.
`FTPControlChannel(String host, int port)`

## Method Summary

Modifier and Type
Method
Description
`void`
`abortTransfer()`
`void`
`close()`
Closes the control channel
`Reply`
`exchange(Command cmd)`
Write the command to the control channel, block until reply arrives and return the reply.
`Reply`
`execute(Command cmd)`
Write the command to the control channel, block until reply arrives and check if the command completed successfully (reply code 200).
`protected BufferedReader`
`getBufferedReader()`
`String`
`getHost()`
`Reply`
`getLastReply()`
Returns the last reply received from the server.
`protected OutputStream`
`getOutputStream()`
`int`
`getPort()`
`protected boolean`
`hasBeenOpened()`
`protected boolean`
`haveStreams()`
`boolean`
`isIPv6()`
`void`
`open()`
opens the connection and returns after it is ready for communication.
`Reply`
`read()`
Block until a reply is available in the control channel.
`protected void`
`readInitialReplies()`
`protected void`
`setInputStream(InputStream in)`
`protected void`
`setOutputStream(OutputStream out)`
`void`
`waitFor(Flag aborted, int ioDelay, int maxWait)`
Block until one of the conditions are true: a reply is available in the control channel, timeout (maxWait) expired aborted flag changes to true.
`void`
`write(Command cmd)`
Sends the command over the control channel.
`protected void`
`writeln(String msg)`
`protected void`
`writeStr(String msg)`

### Methods inherited from class org.globus.ftp.vanilla.BasicClientControlChannel

`waitFor`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### CRLF

public static final String CRLF

See Also:
  - Constant Field Values

### socket

protected Socket socket

### ftpIn

protected BufferedReader ftpIn

### rawFtpIn

protected InputStream rawFtpIn

### ftpOut

protected OutputStream ftpOut

### host

protected String host

### port

protected int port

### hasBeenOpened

protected boolean hasBeenOpened

## Constructor Details

### FTPControlChannel

public FTPControlChannel(String host, int port)

### FTPControlChannel

public FTPControlChannel(InputStream in, OutputStream out)
Using this constructor, you can initialize an instance that does not talk directly to the socket. If you use this constructor using streams that belong to an active connection, there's no need to call open() afterwards.

## Method Details

### getHost

public String getHost()

### getPort

public int getPort()

### isIPv6

public boolean isIPv6()

### getBufferedReader

protected BufferedReader getBufferedReader()

### getOutputStream

protected OutputStream getOutputStream()

### setInputStream

protected void setInputStream(InputStream in)

### setOutputStream

protected void setOutputStream(OutputStream out)

### open

public void open() throws IOException, ServerException
opens the connection and returns after it is ready for communication. Before returning, it intercepts the initial server reply(-ies), and not positive, throws UnexpectedReplyCodeException. After returning, there should be no more queued replies on the line. Here's the sequence for connection establishment (rfc959):

         120
             220
         220
         421

Throws:
  `IOException` - on I/O error
  `ServerException` - on negative or faulty server reply

### readInitialReplies

protected void readInitialReplies() throws IOException, ServerException

Throws:
  `IOException`
  `ServerException`

### getLastReply

public Reply getLastReply()
Returns the last reply received from the server.

### close

public void close() throws IOException
Closes the control channel

Throws:
  `IOException`

### waitFor

public void waitFor(Flag aborted, int ioDelay, int maxWait) throws ServerException, IOException, InterruptedException
Block until one of the conditions are true:

1. a reply is available in the control channel,
2. timeout (maxWait) expired
3. aborted flag changes to true.

If maxWait == WAIT_FOREVER, never timeout and only check conditions (1) and (3).

Specified by:
  `waitFor` in class `BasicClientControlChannel`
Parameters:
  `aborted` - flag indicating wait aborted.
  `ioDelay` - frequency of polling the control channel and checking the conditions
  `maxWait` - timeout in miliseconds
Throws:
  `ServerException`
  `IOException`
  `InterruptedException`

### read

public Reply read() throws ServerException, IOException, FTPReplyParseException, EOFException
Block until a reply is available in the control channel.

Specified by:
  `read` in class `BasicClientControlChannel`
Returns:
  the first unread reply from the control channel.
Throws:
  `IOException` - on I/O error
  `FTPReplyParseException` - on malformatted server reply
  `ServerException`
  `EOFException`

### abortTransfer

public void abortTransfer()

Specified by:
  `abortTransfer` in class `BasicClientControlChannel`

### write

public void write(Command cmd) throws IOException, IllegalArgumentException
Sends the command over the control channel. Do not wait for reply.

Parameters:
  `cmd` - FTP command
Throws:
  `IOException` - on I/O error
  `IllegalArgumentException`

### exchange

public Reply exchange(Command cmd) throws ServerException, IOException, FTPReplyParseException
Write the command to the control channel, block until reply arrives and return the reply. Before calling this method make sure that no old replies are waiting on the control channel. Otherwise the reply returned may not be the reply to this command.

Parameters:
  `cmd` - FTP command
Returns:
  the first reply that waits in the control channel
Throws:
  `IOException` - on I/O error
  `FTPReplyParseException` - on bad reply format
  `ServerException`

### execute

public Reply execute(Command cmd) throws ServerException, IOException, FTPReplyParseException, UnexpectedReplyCodeException
Write the command to the control channel, block until reply arrives and check if the command completed successfully (reply code 200). If so, return the reply, otherwise throw exception. Before calling this method make sure that no old replies are waiting on the control channel. Otherwise the reply returned may not be the reply to this command.

Parameters:
  `cmd` - FTP command
Returns:
  the first reply that waits in the control channel
Throws:
  `IOException` - on I/O error
  `FTPReplyParseException` - on bad reply format
  `UnexpectedReplyCodeException` - if reply is not a positive completion reply (code 200)
  `ServerException`

### writeln

protected void writeln(String msg) throws IOException

Throws:
  `IOException`

### writeStr

protected void writeStr(String msg) throws IOException

Throws:
  `IOException`

### hasBeenOpened

protected boolean hasBeenOpened()

### haveStreams

protected boolean haveStreams()