1. /*

  2.  * Copyright 2003-2004 The Apache Software Foundation

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  *     http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. package org.apache.commons.net.telnet;

  17. import java.io.BufferedInputStream;

  18. import java.io.IOException;

  19. import java.io.InputStream;

  20. import java.io.OutputStream;

  21. import org.apache.commons.net.io.FromNetASCIIInputStream;

  22. import org.apache.commons.net.io.ToNetASCIIOutputStream;

  23. 

  24. /***

  25.  * The TelnetClient class implements the simple network virtual

  26.  * terminal (NVT) for the Telnet protocol according to RFC 854.  It

  27.  * does not implement any of the extra Telnet options because it

  28.  * is meant to be used within a Java program providing automated

  29.  * access to Telnet accessible resources.

  30.  * <p>

  31.  * The class can be used by first connecting to a server using the

  32.  * SocketClient

  33.  * <a href="org.apache.commons.net.SocketClient.html#connect">connect</a>

  34.  * method.  Then an InputStream and OutputStream for sending and

  35.  * receiving data over the Telnet connection can be obtained by

  36.  * using the <a href="#getInputStream"> getInputStream() </a> and

  37.  * <a href="#getOutputStream"> getOutputStream() </a> methods.

  38.  * When you finish using the streams, you must call

  39.  * <a href="#disconnect"> disconnect </a> rather than simply

  40.  * closing the streams.

  41.  * <p>

  42.  * <p>

  43.  * @author Daniel F. Savarese

  44.  * @author Bruno D'Avanzo

  45.  ***/

  46. 

  47. public class TelnetClient extends Telnet

  48. {

  49.     private InputStream __input;

  50.     private OutputStream __output;

  51.     protected boolean readerThread = true;

  52. 

  53.     /***

  54.      * Default TelnetClient constructor.

  55.      ***/

  56.     public TelnetClient()

  57.     {

  58.         /* TERMINAL-TYPE option (start)*/

  59.         super ("VT100");

  60.         /* TERMINAL-TYPE option (end)*/

  61.         __input = null;

  62.         __output = null;

  63.     }

  64. 

  65.     /* TERMINAL-TYPE option (start)*/

  66.     public TelnetClient(String termtype)

  67.     {

  68.         super (termtype);

  69.         __input = null;

  70.         __output = null;

  71.     }

  72.     /* TERMINAL-TYPE option (end)*/

  73. 

  74.     void _flushOutputStream() throws IOException

  75.     {

  76.         _output_.flush();

  77.     }

  78.     void _closeOutputStream() throws IOException

  79.     {

  80.         _output_.close();

  81.     }

  82. 

  83.     /***

  84.      * Handles special connection requirements.

  85.      * <p>

  86.      * @exception IOException  If an error occurs during connection setup.

  87.      ***/

  88.     protected void _connectAction_() throws IOException

  89.     {

  90.         super._connectAction_();

  91.         InputStream input;

  92.         TelnetInputStream tmp;

  93. 

  94.         if (FromNetASCIIInputStream.isConversionRequired())

  95.             input = new FromNetASCIIInputStream(_input_);

  96.         else

  97.             input = _input_;

  98. 

  99. 

  100.         tmp = new TelnetInputStream(input, this);

  101.         if(readerThread)

  102.         {

  103.             tmp._start();

  104.         }

  105.         // __input CANNOT refer to the TelnetInputStream.  We run into

  106.         // blocking problems when some classes use TelnetInputStream, so

  107.         // we wrap it with a BufferedInputStream which we know is safe.

  108.         // This blocking behavior requires further investigation, but right

  109.         // now it looks like classes like InputStreamReader are not implemented

  110.         // in a safe manner.

  111.         __input = new BufferedInputStream(tmp);

  112.         __output = new ToNetASCIIOutputStream(new TelnetOutputStream(this));

  113.     }

  114. 

  115.     /***

  116.      * Disconnects the telnet session, closing the input and output streams

  117.      * as well as the socket.  If you have references to the

  118.      * input and output streams of the telnet connection, you should not

  119.      * close them yourself, but rather call disconnect to properly close

  120.      * the connection.

  121.      ***/

  122.     public void disconnect() throws IOException

  123.     {

  124.         __input.close();

  125.         __output.close();

  126.         super.disconnect();

  127.     }

  128. 

  129.     /***

  130.      * Returns the telnet connection output stream.  You should not close the

  131.      * stream when you finish with it.  Rather, you should call

  132.      * <a href="#disconnect"> disconnect </a>.

  133.      * <p>

  134.      * @return The telnet connection output stream.

  135.      ***/

  136.     public OutputStream getOutputStream()

  137.     {

  138.         return __output;

  139.     }

  140. 

  141.     /***

  142.      * Returns the telnet connection input stream.  You should not close the

  143.      * stream when you finish with it.  Rather, you should call

  144.      * <a href="#disconnect"> disconnect </a>.

  145.      * <p>

  146.      * @return The telnet connection input stream.

  147.      ***/

  148.     public InputStream getInputStream()

  149.     {

  150.         return __input;

  151.     }

  152. 

  153.     /***

  154.      * Returns the state of the option on the local side.

  155.      * <p>

  156.      * @param option - Option to be checked.

  157.      * <p>

  158.      * @return The state of the option on the local side.

  159.      ***/

  160.     public boolean getLocalOptionState(int option)

  161.     {

  162.         /* BUG (option active when not already acknowledged) (start)*/

  163.         return (_stateIsWill(option) && _requestedWill(option));

  164.         /* BUG (option active when not already acknowledged) (end)*/

  165.     }

  166. 

  167.     /***

  168.      * Returns the state of the option on the remote side.

  169.      * <p>

  170.      * @param option - Option to be checked.

  171.      * <p>

  172.      * @return The state of the option on the remote side.

  173.      ***/

  174.     public boolean getRemoteOptionState(int option)

  175.     {

  176.         /* BUG (option active when not already acknowledged) (start)*/

  177.         return (_stateIsDo(option) && _requestedDo(option));

  178.         /* BUG (option active when not already acknowledged) (end)*/

  179.     }

  180.     /* open TelnetOptionHandler functionality (end)*/

  181. 

  182.     /* Code Section added for supporting AYT (start)*/

  183. 

  184.     /***

  185.      * Sends an Are You There sequence and waits for the result.

  186.      * <p>

  187.      * @throws InterruptedException

  188.      * @throws IllegalArgumentException

  189.      * @throws IOException

  190.      * <p>

  191.      * @param timeout - Time to wait for a response (millis.)

  192.      * <p>

  193.      * @return true if AYT received a response, false otherwise

  194.      ***/

  195.     public boolean sendAYT(long timeout)

  196.     throws IOException, IllegalArgumentException, InterruptedException

  197.     {

  198.         return (_sendAYT(timeout));

  199.     }

  200.     /* Code Section added for supporting AYT (start)*/

  201. 

  202.     /* open TelnetOptionHandler functionality (start)*/

  203. 

  204.     /***

  205.      * Registers a new TelnetOptionHandler for this telnet client to use.

  206.      * <p>

  207.      * @throws InvalidTelnetOptionException

  208.      * <p>

  209.      * @param opthand - option handler to be registered.

  210.      ***/

  211.     public void addOptionHandler(TelnetOptionHandler opthand)

  212.     throws InvalidTelnetOptionException

  213.     {

  214.         super.addOptionHandler(opthand);

  215.     }

  216.     /* open TelnetOptionHandler functionality (end)*/

  217. 

  218.     /***

  219.      * Unregisters a  TelnetOptionHandler.

  220.      * <p>

  221.      * @throws InvalidTelnetOptionException

  222.      * <p>

  223.      * @param optcode - Code of the option to be unregistered.

  224.      ***/

  225.     public void deleteOptionHandler(int optcode)

  226.     throws InvalidTelnetOptionException

  227.     {

  228.         super.deleteOptionHandler(optcode);

  229.     }

  230. 

  231.     /* Code Section added for supporting spystreams (start)*/

  232.     /***

  233.      * Registers an OutputStream for spying what's going on in

  234.      * the TelnetClient session.

  235.      * <p>

  236.      * @param spystream - OutputStream on which session activity

  237.      * will be echoed.

  238.      ***/

  239.     public void registerSpyStream(OutputStream  spystream)

  240.     {

  241.         super._registerSpyStream(spystream);

  242.     }

  243. 

  244.     /***

  245.      * Stops spying this TelnetClient.

  246.      * <p>

  247.      ***/

  248.     public void stopSpyStream()

  249.     {

  250.         super._stopSpyStream();

  251.     }

  252.     /* Code Section added for supporting spystreams (end)*/

  253. 

  254.     /***

  255.      * Registers a notification handler to which will be sent

  256.      * notifications of received telnet option negotiation commands.

  257.      * <p>

  258.      * @param notifhand - TelnetNotificationHandler to be registered

  259.      ***/

  260.     public void registerNotifHandler(TelnetNotificationHandler  notifhand)

  261.     {

  262.         super.registerNotifHandler(notifhand);

  263.     }

  264. 

  265.     /***

  266.      * Unregisters the current notification handler.

  267.      * <p>

  268.      ***/

  269.     public void unregisterNotifHandler()

  270.     {

  271.         super.unregisterNotifHandler();

  272.     }

  273. 

  274.     /***

  275.      * Sets the status of the reader thread.

  276.      * The reader thread status will apply to all subsequent connections

  277.      * <p>

  278.      * @param flag - true switches the reader thread on, false switches it off

  279.      ***/

  280.     public void setReaderThread(boolean flag)

  281.     {

  282.         readerThread = flag;

  283.     }

  284. 

  285.     /***

  286.      * Gets the status of the reader thread.

  287.      * <p>

  288.      * @return true if the reader thread is on, false otherwise

  289.      ***/

  290.     public boolean getReaderThread()

  291.     {

  292.         return (readerThread);

  293.     }

  294. }