blob: f491b12212beba83f3792d03638f1b04f1572038 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.net.telnet;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* The TelnetClient class implements the simple network virtual
* terminal (NVT) for the Telnet protocol according to RFC 854. It
* does not implement any of the extra Telnet options because it
* is meant to be used within a Java program providing automated
* access to Telnet accessible resources.
* <p>
* The class can be used by first connecting to a server using the
* SocketClient
* {@link org.apache.commons.net.SocketClient#connect connect}
* method. Then an InputStream and OutputStream for sending and
* receiving data over the Telnet connection can be obtained by
* using the {@link #getInputStream getInputStream() } and
* {@link #getOutputStream getOutputStream() } methods.
* When you finish using the streams, you must call
* {@link #disconnect disconnect } rather than simply
* closing the streams.
*/
public class TelnetClient extends Telnet
{
private static final int DEFAULT_MAX_SUBNEGOTIATION_LENGTH = 512;
final int maxSubnegotiationLength;
private InputStream input;
private OutputStream output;
protected boolean readerThread = true;
private TelnetInputListener inputListener;
/**
* Default TelnetClient constructor, sets terminal-type {@code VT100}.
*/
public TelnetClient()
{
this("VT100", DEFAULT_MAX_SUBNEGOTIATION_LENGTH);
}
/**
* Construct an instance with the specified max subnegotiation
* length and the default terminal-type {@code VT100}
*
* @param maxSubnegotiationLength the size of the subnegotiation buffer
*/
public TelnetClient(final int maxSubnegotiationLength)
{
this("VT100", maxSubnegotiationLength);
}
/**
* Construct an instance with the specified terminal type.
*
* @param termtype the terminal type to use, e.g. {@code VT100}
*/
public TelnetClient(final String termtype)
{
this(termtype, DEFAULT_MAX_SUBNEGOTIATION_LENGTH);
}
/**
* Construct an instance with the specified terminal type
* and max subnegotiation length
*
* @param termtype the terminal type to use, e.g. {@code VT100}
* @param maxSubnegotiationLength the size of the subnegotiation buffer
*/
public TelnetClient(final String termtype, final int maxSubnegotiationLength)
{
/* TERMINAL-TYPE option (start)*/
super(termtype);
/* TERMINAL-TYPE option (end)*/
this.input = null;
this.output = null;
this.maxSubnegotiationLength = maxSubnegotiationLength;
}
/**
* Handles special connection requirements.
*
* @throws IOException If an error occurs during connection setup.
*/
@Override
protected void _connectAction_() throws IOException
{
super._connectAction_();
final TelnetInputStream tmp = new TelnetInputStream(_input_, this, readerThread);
if(readerThread)
{
tmp.start();
}
// __input CANNOT refer to the TelnetInputStream. We run into
// blocking problems when some classes use TelnetInputStream, so
// we wrap it with a BufferedInputStream which we know is safe.
// This blocking behavior requires further investigation, but right
// now it looks like classes like InputStreamReader are not implemented
// in a safe manner.
input = new BufferedInputStream(tmp);
output = new TelnetOutputStream(this);
}
/**
* Registers a new TelnetOptionHandler for this telnet client to use.
*
* @param opthand - option handler to be registered.
*
* @throws InvalidTelnetOptionException on error
* @throws IOException on error
*/
@Override
public void addOptionHandler(final TelnetOptionHandler opthand)
throws InvalidTelnetOptionException, IOException
{
super.addOptionHandler(opthand);
}
/* open TelnetOptionHandler functionality (end)*/
void closeOutputStream() throws IOException
{
if (_output_ == null) {
return;
}
try {
_output_.close();
} finally {
_output_ = null;
}
}
/**
* Unregisters a TelnetOptionHandler.
*
* @param optcode - Code of the option to be unregistered.
*
* @throws InvalidTelnetOptionException on error
* @throws IOException on error
*/
@Override
public void deleteOptionHandler(final int optcode)
throws InvalidTelnetOptionException, IOException
{
super.deleteOptionHandler(optcode);
}
/**
* Disconnects the telnet session, closing the input and output streams
* as well as the socket. If you have references to the
* input and output streams of the telnet connection, you should not
* close them yourself, but rather call disconnect to properly close
* the connection.
*/
@Override
public void disconnect() throws IOException
{
try {
if (input != null) {
input.close();
}
if (output != null) {
output.close();
}
} finally { // NET-594
output = null;
input = null;
super.disconnect();
}
}
void flushOutputStream() throws IOException
{
if (_output_ == null) {
throw new IOException("Stream closed");
}
_output_.flush();
}
/**
* Returns the telnet connection input stream. You should not close the
* stream when you finish with it. Rather, you should call
* {@link #disconnect disconnect }.
*
* @return The telnet connection input stream.
*/
public InputStream getInputStream()
{
return input;
}
/**
* Returns the state of the option on the local side.
*
* @param option - Option to be checked.
*
* @return The state of the option on the local side.
*/
public boolean getLocalOptionState(final int option)
{
/* BUG (option active when not already acknowledged) (start)*/
return stateIsWill(option) && requestedWill(option);
/* BUG (option active when not already acknowledged) (end)*/
}
/* Code Section added for supporting AYT (start)*/
/**
* Returns the telnet connection output stream. You should not close the
* stream when you finish with it. Rather, you should call
* {@link #disconnect disconnect }.
*
* @return The telnet connection output stream.
*/
public OutputStream getOutputStream()
{
return output;
}
/**
* Gets the status of the reader thread.
*
* @return true if the reader thread is enabled, false otherwise
*/
public boolean getReaderThread()
{
return readerThread;
}
/**
* Returns the state of the option on the remote side.
*
* @param option - Option to be checked.
*
* @return The state of the option on the remote side.
*/
public boolean getRemoteOptionState(final int option)
{
/* BUG (option active when not already acknowledged) (start)*/
return stateIsDo(option) && requestedDo(option);
/* BUG (option active when not already acknowledged) (end)*/
}
/* open TelnetOptionHandler functionality (end)*/
/* open TelnetOptionHandler functionality (start)*/
// Notify input listener
void notifyInputListener() {
final TelnetInputListener listener;
synchronized (this) {
listener = this.inputListener;
}
if (listener != null) {
listener.telnetInputAvailable();
}
}
/**
* Register a listener to be notified when new incoming data is
* available to be read on the {@link #getInputStream input stream}.
* Only one listener is supported at a time.
*
* <p>
* More precisely, notifications are issued whenever the number of
* bytes available for immediate reading (i.e., the value returned
* by {@link InputStream#available}) transitions from zero to non-zero.
* Note that (in general) multiple reads may be required to empty the
* buffer and reset this notification, because incoming bytes are being
* added to the internal buffer asynchronously.
* </p>
*
* <p>
* Notifications are only supported when a {@link #setReaderThread
* reader thread} is enabled for the connection.
* </p>
*
* @param listener listener to be registered; replaces any previous
* @since 3.0
*/
public synchronized void registerInputListener(final TelnetInputListener listener)
{
this.inputListener = listener;
}
/**
* Registers a notification handler to which will be sent
* notifications of received telnet option negotiation commands.
*
* @param notifhand - TelnetNotificationHandler to be registered
*/
@Override
public void registerNotifHandler(final TelnetNotificationHandler notifhand)
{
super.registerNotifHandler(notifhand);
}
/* Code Section added for supporting spystreams (start)*/
/**
* Registers an OutputStream for spying what's going on in
* the TelnetClient session.
*
* @param spystream - OutputStream on which session activity
* will be echoed.
*/
public void registerSpyStream(final OutputStream spystream)
{
super._registerSpyStream(spystream);
}
/**
* Sends an Are You There sequence and waits for the result.
*
* @param timeout - Time to wait for a response (millis.)
*
* @return true if AYT received a response, false otherwise
*
* @throws InterruptedException on error
* @throws IllegalArgumentException on error
* @throws IOException on error
*/
public boolean sendAYT(final long timeout)
throws IOException, IllegalArgumentException, InterruptedException
{
return _sendAYT(timeout);
}
/* Code Section added for supporting AYT (start)*/
/**
* Sends a command byte to the remote peer, adding the IAC prefix.
*
* <p>
* This method does not wait for any response. Messages
* sent by the remote end can be handled by registering an approrpriate
* {@link TelnetOptionHandler}.
* </p>
*
* @param command the code for the command
* @throws IOException if an I/O error occurs while writing the message
* @throws IllegalArgumentException on error
* @since 3.0
*/
public void sendCommand(final byte command)
throws IOException, IllegalArgumentException
{
_sendCommand(command);
}
/**
* Sends a protocol-specific subnegotiation message to the remote peer.
* {@link TelnetClient} will add the IAC SB &amp; IAC SE framing bytes;
* the first byte in {@code message} should be the appropriate telnet
* option code.
*
* <p>
* This method does not wait for any response. Subnegotiation messages
* sent by the remote end can be handled by registering an approrpriate
* {@link TelnetOptionHandler}.
* </p>
*
* @param message option code followed by subnegotiation payload
* @throws IllegalArgumentException if {@code message} has length zero
* @throws IOException if an I/O error occurs while writing the message
* @since 3.0
*/
public void sendSubnegotiation(final int[] message)
throws IOException, IllegalArgumentException
{
if (message.length < 1) {
throw new IllegalArgumentException("zero length message");
}
_sendSubnegotiation(message);
}
/**
* Sets the status of the reader thread.
*
* <p>
* When enabled, a seaparate internal reader thread is created for new
* connections to read incoming data as it arrives. This results in
* immediate handling of option negotiation, notifications, etc.
* (at least until the fixed-size internal buffer fills up).
* Otherwise, no thread is created an all negotiation and option
* handling is deferred until a read() is performed on the
* {@link #getInputStream input stream}.
* </p>
*
* <p>
* The reader thread must be enabled for {@link TelnetInputListener}
* support.
* </p>
*
* <p>
* When this method is invoked, the reader thread status will apply to all
* subsequent connections; the current connection (if any) is not affected.
* </p>
*
* @param flag true to enable the reader thread, false to disable
* @see #registerInputListener
*/
public void setReaderThread(final boolean flag)
{
readerThread = flag;
}
/**
* Stops spying this TelnetClient.
*
*/
public void stopSpyStream()
{
super._stopSpyStream();
}
/* Code Section added for supporting spystreams (end)*/
/**
* Unregisters the current {@link TelnetInputListener}, if any.
*
* @since 3.0
*/
public synchronized void unregisterInputListener()
{
this.inputListener = null;
}
/**
* Unregisters the current notification handler.
*
*/
@Override
public void unregisterNotifHandler()
{
super.unregisterNotifHandler();
}
}