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.BufferedOutputStream;

  19. import java.io.OutputStream;

  20. import java.io.IOException;

  21. import org.apache.commons.net.SocketClient;

  22. 

  23. /**

  24.  * @author Daniel F. Savarese

  25.  * @author Bruno D'Avanzo

  26.  */

  27. 

  28. class Telnet extends SocketClient

  29. {

  30.     static final boolean debug =  /*true;*/ false;

  31. 

  32.     static final boolean debugoptions =  /*true;*/ false;

  33. 

  34.     static final byte[] _COMMAND_DO = {

  35.                                           (byte)TelnetCommand.IAC, (byte)TelnetCommand.DO

  36.                                       };

  37. 

  38.     static final byte[] _COMMAND_DONT = {

  39.                                             (byte)TelnetCommand.IAC, (byte)TelnetCommand.DONT

  40.                                         };

  41. 

  42.     static final byte[] _COMMAND_WILL = {

  43.                                             (byte)TelnetCommand.IAC, (byte)TelnetCommand.WILL

  44.                                         };

  45. 

  46.     static final byte[] _COMMAND_WONT = {

  47.                                             (byte)TelnetCommand.IAC, (byte)TelnetCommand.WONT

  48.                                         };

  49. 

  50.     static final byte[] _COMMAND_SB = {

  51.                                           (byte)TelnetCommand.IAC, (byte)TelnetCommand.SB

  52.                                       };

  53. 

  54.     static final byte[] _COMMAND_SE = {

  55.                                           (byte)TelnetCommand.IAC, (byte)TelnetCommand.SE

  56.                                       };

  57. 

  58.     static final int _WILL_MASK = 0x01, _DO_MASK = 0x02,

  59.                                   _REQUESTED_WILL_MASK = 0x04, _REQUESTED_DO_MASK = 0x08;

  60. 

  61.     /* public */

  62.     static final int DEFAULT_PORT =  23;

  63. 

  64.     int[] _doResponse, _willResponse, _options;

  65. 

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

  67.     /***

  68.      * Terminal type option

  69.      ***/

  70.     protected static final int TERMINAL_TYPE = 24;

  71. 

  72.     /***

  73.      * Send (for subnegotiation)

  74.      ***/

  75.     protected static final int TERMINAL_TYPE_SEND =  1;

  76. 

  77.     /***

  78.      * Is (for subnegotiation)

  79.      ***/

  80.     protected static final int TERMINAL_TYPE_IS =  0;

  81. 

  82.     /***

  83.      * Is sequence (for subnegotiation)

  84.      ***/

  85.     static final byte[] _COMMAND_IS = {

  86.                                           (byte) TERMINAL_TYPE, (byte) TERMINAL_TYPE_IS

  87.                                       };

  88. 

  89.     /***

  90.      * Terminal type

  91.      ***/

  92.     private String terminalType = null;

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

  94. 

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

  96.     /***

  97.      * Array of option handlers

  98.      ***/

  99.     private TelnetOptionHandler optionHandlers[];

  100. 

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

  102. 

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

  104.     /***

  105.      * AYT sequence

  106.      ***/

  107.     static final byte[] _COMMAND_AYT = {

  108.                                           (byte) TelnetCommand.IAC, (byte) TelnetCommand.AYT

  109.                                        };

  110. 

  111.     /***

  112.      * monitor to wait for AYT

  113.      ***/

  114.     private Object aytMonitor = new Object();

  115. 

  116.     /***

  117.      * flag for AYT

  118.      ***/

  119.     private boolean aytFlag = true;

  120.     /* Code Section added for supporting AYT (end)*/

  121. 

  122.     /***

  123.      * The stream on which to spy

  124.      ***/

  125.     private OutputStream spyStream = null;

  126. 

  127.     /***

  128.      * The notification handler

  129.      ***/

  130.     private TelnetNotificationHandler __notifhand = null;

  131.     /***

  132.      * Empty Constructor

  133.      ***/

  134.     Telnet()

  135.     {

  136.         setDefaultPort(DEFAULT_PORT);

  137.         _doResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];

  138.         _willResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];

  139.         _options = new int[TelnetOption.MAX_OPTION_VALUE + 1];

  140.         optionHandlers =

  141.             new TelnetOptionHandler[TelnetOption.MAX_OPTION_VALUE + 1];

  142.     }

  143. 

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

  145.     /***

  146.      * This constructor lets you specify the terminal type.

  147.      * <p>

  148.      * @param termtype - terminal type to be negotiated (ej. VT100)

  149.      ***/

  150.     Telnet(String termtype)

  151.     {

  152.         setDefaultPort(DEFAULT_PORT);

  153.         _doResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];

  154.         _willResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];

  155.         _options = new int[TelnetOption.MAX_OPTION_VALUE + 1];

  156.         terminalType = termtype;

  157.         optionHandlers =

  158.             new TelnetOptionHandler[TelnetOption.MAX_OPTION_VALUE + 1];

  159.     }

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

  161. 

  162.     /***

  163.      * Looks for the state of the option.

  164.      * <p>

  165.      * @return returns true if a will has been acknowledged

  166.      * <p>

  167.      * @param option - option code to be looked up.

  168.      ***/

  169.     boolean _stateIsWill(int option)

  170.     {

  171.         return ((_options[option] & _WILL_MASK) != 0);

  172.     }

  173. 

  174.     /***

  175.      * Looks for the state of the option.

  176.      * <p>

  177.      * @return returns true if a wont has been acknowledged

  178.      * <p>

  179.      * @param option - option code to be looked up.

  180.      ***/

  181.     boolean _stateIsWont(int option)

  182.     {

  183.         return !_stateIsWill(option);

  184.     }

  185. 

  186.     /***

  187.      * Looks for the state of the option.

  188.      * <p>

  189.      * @return returns true if a do has been acknowledged

  190.      * <p>

  191.      * @param option - option code to be looked up.

  192.      ***/

  193.     boolean _stateIsDo(int option)

  194.     {

  195.         return ((_options[option] & _DO_MASK) != 0);

  196.     }

  197. 

  198.     /***

  199.      * Looks for the state of the option.

  200.      * <p>

  201.      * @return returns true if a dont has been acknowledged

  202.      * <p>

  203.      * @param option - option code to be looked up.

  204.      ***/

  205.     boolean _stateIsDont(int option)

  206.     {

  207.         return !_stateIsDo(option);

  208.     }

  209. 

  210.     /***

  211.      * Looks for the state of the option.

  212.      * <p>

  213.      * @return returns true if a will has been reuqested

  214.      * <p>

  215.      * @param option - option code to be looked up.

  216.      ***/

  217.     boolean _requestedWill(int option)

  218.     {

  219.         return ((_options[option] & _REQUESTED_WILL_MASK) != 0);

  220.     }

  221. 

  222.     /***

  223.      * Looks for the state of the option.

  224.      * <p>

  225.      * @return returns true if a wont has been reuqested

  226.      * <p>

  227.      * @param option - option code to be looked up.

  228.      ***/

  229.     boolean _requestedWont(int option)

  230.     {

  231.         return !_requestedWill(option);

  232.     }

  233. 

  234.     /***

  235.      * Looks for the state of the option.

  236.      * <p>

  237.      * @return returns true if a do has been reuqested

  238.      * <p>

  239.      * @param option - option code to be looked up.

  240.      ***/

  241.     boolean _requestedDo(int option)

  242.     {

  243.         return ((_options[option] & _REQUESTED_DO_MASK) != 0);

  244.     }

  245. 

  246.     /***

  247.      * Looks for the state of the option.

  248.      * <p>

  249.      * @return returns true if a dont has been reuqested

  250.      * <p>

  251.      * @param option - option code to be looked up.

  252.      ***/

  253.     boolean _requestedDont(int option)

  254.     {

  255.         return !_requestedDo(option);

  256.     }

  257. 

  258.     /***

  259.      * Sets the state of the option.

  260.      * <p>

  261.      * @param option - option code to be set.

  262.      ***/

  263.     void _setWill(int option)

  264.     {

  265.         _options[option] |= _WILL_MASK;

  266. 

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

  268.         if (_requestedWill(option))

  269.         {

  270.             if (optionHandlers[option] != null)

  271.             {

  272.                 optionHandlers[option].setWill(true);

  273. 

  274.                 int subneg[] =

  275.                     optionHandlers[option].startSubnegotiationLocal();

  276. 

  277.                 if (subneg != null)

  278.                 {

  279.                     try

  280.                     {

  281.                         _sendSubnegotiation(subneg);

  282.                     }

  283.                     catch (Exception e)

  284.                     {

  285.                         System.err.println(

  286.                             "Exception in option subnegotiation"

  287.                             + e.getMessage());

  288.                     }

  289.                 }

  290.             }

  291.         }

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

  293.     }

  294. 

  295.     /***

  296.      * Sets the state of the option.

  297.      * <p>

  298.      * @param option - option code to be set.

  299.      ***/

  300.     void _setDo(int option)

  301.     {

  302.         _options[option] |= _DO_MASK;

  303. 

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

  305.         if (_requestedDo(option))

  306.         {

  307.             if (optionHandlers[option] != null)

  308.             {

  309.                 optionHandlers[option].setDo(true);

  310. 

  311.                 int subneg[] =

  312.                     optionHandlers[option].startSubnegotiationRemote();

  313. 

  314.                 if (subneg != null)

  315.                 {

  316.                     try

  317.                     {

  318.                         _sendSubnegotiation(subneg);

  319.                     }

  320.                     catch (Exception e)

  321.                     {

  322.                         System.err.println("Exception in option subnegotiation"

  323.                             + e.getMessage());

  324.                     }

  325.                 }

  326.             }

  327.         }

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

  329.     }

  330. 

  331.     /***

  332.      * Sets the state of the option.

  333.      * <p>

  334.      * @param option - option code to be set.

  335.      ***/

  336.     void _setWantWill(int option)

  337.     {

  338.         _options[option] |= _REQUESTED_WILL_MASK;

  339.     }

  340. 

  341.     /***

  342.      * Sets the state of the option.

  343.      * <p>

  344.      * @param option - option code to be set.

  345.      ***/

  346.     void _setWantDo(int option)

  347.     {

  348.         _options[option] |= _REQUESTED_DO_MASK;

  349.     }

  350. 

  351.     /***

  352.      * Sets the state of the option.

  353.      * <p>

  354.      * @param option - option code to be set.

  355.      ***/

  356.     void _setWont(int option)

  357.     {

  358.         _options[option] &= ~_WILL_MASK;

  359. 

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

  361.         if (optionHandlers[option] != null)

  362.         {

  363.             optionHandlers[option].setWill(false);

  364.         }

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

  366.     }

  367. 

  368.     /***

  369.      * Sets the state of the option.

  370.      * <p>

  371.      * @param option - option code to be set.

  372.      ***/

  373.     void _setDont(int option)

  374.     {

  375.         _options[option] &= ~_DO_MASK;

  376. 

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

  378.         if (optionHandlers[option] != null)

  379.         {

  380.             optionHandlers[option].setDo(false);

  381.         }

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

  383.     }

  384. 

  385.     /***

  386.      * Sets the state of the option.

  387.      * <p>

  388.      * @param option - option code to be set.

  389.      ***/

  390.     void _setWantWont(int option)

  391.     {

  392.         _options[option] &= ~_REQUESTED_WILL_MASK;

  393.     }

  394. 

  395.     /***

  396.      * Sets the state of the option.

  397.      * <p>

  398.      * @param option - option code to be set.

  399.      ***/

  400.     void _setWantDont(int option)

  401.     {

  402.         _options[option] &= ~_REQUESTED_DO_MASK;

  403.     }

  404. 

  405.     /***

  406.      * Processes a DO request.

  407.      * <p>

  408.      * @throws IOException - Exception in I/O.

  409.      * <p>

  410.      * @param option - option code to be set.

  411.      ***/

  412.     void _processDo(int option) throws IOException

  413.     {

  414.         if (debugoptions)

  415.         {

  416.             System.err.println("RECEIVED DO: "

  417.                 + TelnetOption.getOption(option));

  418.         }

  419. 

  420.         if (__notifhand != null)

  421.         {

  422.             __notifhand.receivedNegotiation(

  423.                 TelnetNotificationHandler.RECEIVED_DO,

  424.                 option);

  425.         }

  426. 

  427.         boolean acceptNewState = false;

  428. 

  429. 

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

  431.         if (optionHandlers[option] != null)

  432.         {

  433.             acceptNewState = optionHandlers[option].getAcceptLocal();

  434.         }

  435.         else

  436.         {

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

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

  439.             if (option == TERMINAL_TYPE)

  440.             {

  441.                 if ((terminalType != null) && (terminalType.length() > 0))

  442.                 {

  443.                     acceptNewState = true;

  444.                 }

  445.             }

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

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

  448.         }

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

  450. 

  451.         if (_willResponse[option] > 0)

  452.         {

  453.             --_willResponse[option];

  454.             if (_willResponse[option] > 0 && _stateIsWill(option))

  455.             {

  456.                 --_willResponse[option];

  457.             }

  458.         }

  459. 

  460.         if (_willResponse[option] == 0)

  461.         {

  462.             if (_requestedWont(option))

  463.             {

  464. 

  465.                 switch (option)

  466.                 {

  467. 

  468.                 default:

  469.                     break;

  470. 

  471.                 }

  472. 

  473. 

  474.                 if (acceptNewState)

  475.                 {

  476.                     _setWantWill(option);

  477.                     _sendWill(option);

  478.                 }

  479.                 else

  480.                 {

  481.                     ++_willResponse[option];

  482.                     _sendWont(option);

  483.                 }

  484.             }

  485.             else

  486.             {

  487.                 // Other end has acknowledged option.

  488. 

  489.                 switch (option)

  490.                 {

  491. 

  492.                 default:

  493.                     break;

  494. 

  495.                 }

  496. 

  497.             }

  498.         }

  499. 

  500.         _setWill(option);

  501.     }

  502. 

  503.     /***

  504.      * Processes a DONT request.

  505.      * <p>

  506.      * @throws IOException - Exception in I/O.

  507.      * <p>

  508.      * @param option - option code to be set.

  509.      ***/

  510.     void _processDont(int option) throws IOException

  511.     {

  512.         if (debugoptions)

  513.         {

  514.             System.err.println("RECEIVED DONT: "

  515.                 + TelnetOption.getOption(option));

  516.         }

  517.         if (__notifhand != null)

  518.         {

  519.             __notifhand.receivedNegotiation(

  520.                 TelnetNotificationHandler.RECEIVED_DONT,

  521.                 option);

  522.         }

  523.         if (_willResponse[option] > 0)

  524.         {

  525.             --_willResponse[option];

  526.             if (_willResponse[option] > 0 && _stateIsWont(option))

  527.             {

  528.                 --_willResponse[option];

  529.             }

  530.         }

  531. 

  532.         if (_willResponse[option] == 0 && _requestedWill(option))

  533.         {

  534. 

  535.             switch (option)

  536.             {

  537. 

  538.             default:

  539.                 break;

  540. 

  541.             }

  542. 

  543.             /* FIX for a BUG in the negotiation (start)*/

  544.             if ((_stateIsWill(option)) || (_requestedWill(option)))

  545.             {

  546.                 _sendWont(option);

  547.             }

  548. 

  549.             _setWantWont(option);

  550.             /* FIX for a BUG in the negotiation (end)*/

  551.         }

  552. 

  553.         _setWont(option);

  554.     }

  555. 

  556. 

  557.     /***

  558.      * Processes a WILL request.

  559.      * <p>

  560.      * @throws IOException - Exception in I/O.

  561.      * <p>

  562.      * @param option - option code to be set.

  563.      ***/

  564.     void _processWill(int option) throws IOException

  565.     {

  566.         if (debugoptions)

  567.         {

  568.             System.err.println("RECEIVED WILL: "

  569.                 + TelnetOption.getOption(option));

  570.         }

  571. 

  572.         if (__notifhand != null)

  573.         {

  574.             __notifhand.receivedNegotiation(

  575.                 TelnetNotificationHandler.RECEIVED_WILL,

  576.                 option);

  577.         }

  578. 

  579.         boolean acceptNewState = false;

  580. 

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

  582.         if (optionHandlers[option] != null)

  583.         {

  584.             acceptNewState = optionHandlers[option].getAcceptRemote();

  585.         }

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

  587. 

  588.         if (_doResponse[option] > 0)

  589.         {

  590.             --_doResponse[option];

  591.             if (_doResponse[option] > 0 && _stateIsDo(option))

  592.             {

  593.                 --_doResponse[option];

  594.             }

  595.         }

  596. 

  597.         if (_doResponse[option] == 0 && _requestedDont(option))

  598.         {

  599. 

  600.             switch (option)

  601.             {

  602. 

  603.             default:

  604.                 break;

  605. 

  606.             }

  607. 

  608. 

  609.             if (acceptNewState)

  610.             {

  611.                 _setWantDo(option);

  612.                 _sendDo(option);

  613.             }

  614.             else

  615.             {

  616.                 ++_doResponse[option];

  617.                 _sendDont(option);

  618.             }

  619.         }

  620. 

  621.         _setDo(option);

  622.     }

  623. 

  624.     /***

  625.      * Processes a WONT request.

  626.      * <p>

  627.      * @throws IOException - Exception in I/O.

  628.      * <p>

  629.      * @param option - option code to be set.

  630.      ***/

  631.     void _processWont(int option) throws IOException

  632.     {

  633.         if (debugoptions)

  634.         {

  635.             System.err.println("RECEIVED WONT: "

  636.                 + TelnetOption.getOption(option));

  637.         }

  638. 

  639.         if (__notifhand != null)

  640.         {

  641.             __notifhand.receivedNegotiation(

  642.                 TelnetNotificationHandler.RECEIVED_WONT,

  643.                 option);

  644.         }

  645. 

  646.         if (_doResponse[option] > 0)

  647.         {

  648.             --_doResponse[option];

  649.             if (_doResponse[option] > 0 && _stateIsDont(option))

  650.             {

  651.                 --_doResponse[option];

  652.             }

  653.         }

  654. 

  655.         if (_doResponse[option] == 0 && _requestedDo(option))

  656.         {

  657. 

  658.             switch (option)

  659.             {

  660. 

  661.             default:

  662.                 break;

  663. 

  664.             }

  665. 

  666.             /* FIX for a BUG in the negotiation (start)*/

  667.             if ((_stateIsDo(option)) || (_requestedDo(option)))

  668.             {

  669.                 _sendDont(option);

  670.             }

  671. 

  672.             _setWantDont(option);

  673.             /* FIX for a BUG in the negotiation (end)*/

  674.         }

  675. 

  676.         _setDont(option);

  677.     }

  678. 

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

  680.     /***

  681.      * Processes a suboption negotiation.

  682.      * <p>

  683.      * @throws IOException - Exception in I/O.

  684.      * <p>

  685.      * @param suboption - subnegotiation data received

  686.      * @param suboptionLength - length of data received

  687.      ***/

  688.     void _processSuboption(int suboption[], int suboptionLength)

  689.     throws IOException

  690.     {

  691.         if (debug)

  692.         {

  693.             System.err.println("PROCESS SUBOPTION.");

  694.         }

  695. 

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

  697.         if (suboptionLength > 0)

  698.         {

  699.             if (optionHandlers[suboption[0]] != null)

  700.             {

  701.                 int responseSuboption[] =

  702.                   optionHandlers[suboption[0]].answerSubnegotiation(suboption,

  703.                   suboptionLength);

  704.                 _sendSubnegotiation(responseSuboption);

  705.             }

  706.             else

  707.             {

  708.                 if (suboptionLength > 1)

  709.                 {

  710.                     if (debug)

  711.                     {

  712.                         for (int ii = 0; ii < suboptionLength; ii++)

  713.                         {

  714.                             System.err.println("SUB[" + ii + "]: "

  715.                                 + suboption[ii]);

  716.                         }

  717.                     }

  718.                     if ((suboption[0] == TERMINAL_TYPE)

  719.                         && (suboption[1] == TERMINAL_TYPE_SEND))

  720.                     {

  721.                         _sendTerminalType();

  722.                     }

  723.                 }

  724.             }

  725.         }

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

  727.     }

  728. 

  729.     /***

  730.      * Sends terminal type information.

  731.      * <p>

  732.      * @throws IOException - Exception in I/O.

  733.      ***/

  734.     final synchronized void _sendTerminalType()

  735.     throws IOException

  736.     {

  737.         if (debug)

  738.         {

  739.             System.err.println("SEND TERMINAL-TYPE: " + terminalType);

  740.         }

  741.         if (terminalType != null)

  742.         {

  743.             _output_.write(_COMMAND_SB);

  744.             _output_.write(_COMMAND_IS);

  745.             _output_.write(terminalType.getBytes());

  746.             _output_.write(_COMMAND_SE);

  747.             _output_.flush();

  748.         }

  749.     }

  750. 

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

  752. 

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

  754.     /***

  755.      * Manages subnegotiation for Terminal Type.

  756.      * <p>

  757.      * @throws IOException - Exception in I/O.

  758.      * <p>

  759.      * @param subn - subnegotiation data to be sent

  760.      ***/

  761.     final synchronized void _sendSubnegotiation(int subn[])

  762.     throws IOException

  763.     {

  764.         if (debug)

  765.         {

  766.             System.err.println("SEND SUBNEGOTIATION: ");

  767.             if (subn != null)

  768.             {

  769.                 for (int ii = 0; ii < subn.length; ii++)

  770.                 {

  771.                     System.err.println("subn["  + ii + "]=" + subn[ii]);

  772.                 }

  773.             }

  774.         }

  775.         if (subn != null)

  776.         {

  777.             byte byteresp[] = new byte[subn.length];

  778.             for (int ii = 0; ii < subn.length; ii++)

  779.             {

  780.                 byteresp[ii] = (byte) subn[ii];

  781.             }

  782. 

  783.             _output_.write(_COMMAND_SB);

  784.             _output_.write(byteresp);

  785.             _output_.write(_COMMAND_SE);

  786. 

  787.             /* Code Section added for sending the negotiation ASAP (start)*/

  788.             _output_.flush();

  789.             /* Code Section added for sending the negotiation ASAP (end)*/

  790.         }

  791.     }

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

  793. 

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

  795.     /***

  796.      * Processes the response of an AYT

  797.      ***/

  798.     final synchronized void _processAYTResponse()

  799.     {

  800.         if (!aytFlag)

  801.         {

  802.             synchronized (aytMonitor)

  803.             {

  804.                 aytFlag = true;

  805.                 try

  806.                 {

  807.                     aytMonitor.notifyAll();

  808.                 }

  809.                 catch (Exception e)

  810.                 {

  811.                     System.err.println("Exception notifying:" + e.getMessage());

  812.                 }

  813.             }

  814.         }

  815.     }

  816.     /* Code Section added for supporting AYT (end)*/

  817. 

  818.     /***

  819.      * Called upon connection.

  820.      * <p>

  821.      * @throws IOException - Exception in I/O.

  822.      ***/

  823.     protected void _connectAction_() throws IOException

  824.     {

  825.         /* (start). BUGFIX: clean the option info for each connection*/

  826.         for (int ii = 0; ii < TelnetOption.MAX_OPTION_VALUE + 1; ii++)

  827.         {

  828.             _doResponse[ii] = 0;

  829.             _willResponse[ii] = 0;

  830.             _options[ii] = 0;

  831.             if (optionHandlers[ii] != null)

  832.             {

  833.                 optionHandlers[ii].setDo(false);

  834.                 optionHandlers[ii].setWill(false);

  835.             }

  836.         }

  837.         /* (end). BUGFIX: clean the option info for each connection*/

  838. 

  839.         super._connectAction_();

  840.         _input_ = new BufferedInputStream(_input_);

  841.         _output_ = new BufferedOutputStream(_output_);

  842. 

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

  844.         for (int ii = 0; ii < TelnetOption.MAX_OPTION_VALUE + 1; ii++)

  845.         {

  846.             if (optionHandlers[ii] != null)

  847.             {

  848.                 if (optionHandlers[ii].getInitLocal())

  849.                 {

  850.                     try

  851.                     {

  852.                         _requestWill(optionHandlers[ii].getOptionCode());

  853.                     }

  854.                     catch (IOException e)

  855.                     {

  856.                         System.err.println(

  857.                             "Exception while initializing option: "

  858.                             + e.getMessage());

  859.                     }

  860.                 }

  861. 

  862.                 if (optionHandlers[ii].getInitRemote())

  863.                 {

  864.                     try

  865.                     {

  866.                         _requestDo(optionHandlers[ii].getOptionCode());

  867.                     }

  868.                     catch (IOException e)

  869.                     {

  870.                         System.err.println(

  871.                             "Exception while initializing option: "

  872.                             + e.getMessage());

  873.                     }

  874.                 }

  875.             }

  876.         }

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

  878.     }

  879. 

  880.     /***

  881.      * Sends a DO.

  882.      * <p>

  883.      * @throws IOException - Exception in I/O.

  884.      * <p>

  885.      * @param option - Option code.

  886.      ***/

  887.     final synchronized void _sendDo(int option)

  888.     throws IOException

  889.     {

  890.         if (debug || debugoptions)

  891.         {

  892.             System.err.println("DO: " + TelnetOption.getOption(option));

  893.         }

  894.         _output_.write(_COMMAND_DO);

  895.         _output_.write(option);

  896. 

  897.         /* Code Section added for sending the negotiation ASAP (start)*/

  898.         _output_.flush();

  899.         /* Code Section added for sending the negotiation ASAP (end)*/

  900.     }

  901. 

  902.     /***

  903.      * Requests a DO.

  904.      * <p>

  905.      * @throws IOException - Exception in I/O.

  906.      * <p>

  907.      * @param option - Option code.

  908.      ***/

  909.     final synchronized void _requestDo(int option)

  910.     throws IOException

  911.     {

  912.         if ((_doResponse[option] == 0 && _stateIsDo(option))

  913.             || _requestedDo(option))

  914.         {

  915.             return ;

  916.         }

  917.         _setWantDo(option);

  918.         ++_doResponse[option];

  919.         _sendDo(option);

  920.     }

  921. 

  922.     /***

  923.      * Sends a DONT.

  924.      * <p>

  925.      * @throws IOException - Exception in I/O.

  926.      * <p>

  927.      * @param option - Option code.

  928.      ***/

  929.     final synchronized void _sendDont(int option)

  930.     throws IOException

  931.     {

  932.         if (debug || debugoptions)

  933.         {

  934.             System.err.println("DONT: " + TelnetOption.getOption(option));

  935.         }

  936.         _output_.write(_COMMAND_DONT);

  937.         _output_.write(option);

  938. 

  939.         /* Code Section added for sending the negotiation ASAP (start)*/

  940.         _output_.flush();

  941.         /* Code Section added for sending the negotiation ASAP (end)*/

  942.     }

  943. 

  944.     /***

  945.      * Requests a DONT.

  946.      * <p>

  947.      * @throws IOException - Exception in I/O.

  948.      * <p>

  949.      * @param option - Option code.

  950.      ***/

  951.     final synchronized void _requestDont(int option)

  952.     throws IOException

  953.     {

  954.         if ((_doResponse[option] == 0 && _stateIsDont(option))

  955.             || _requestedDont(option))

  956.         {

  957.             return ;

  958.         }

  959.         _setWantDont(option);

  960.         ++_doResponse[option];

  961.         _sendDont(option);

  962.     }

  963. 

  964. 

  965.     /***

  966.      * Sends a WILL.

  967.      * <p>

  968.      * @throws IOException - Exception in I/O.

  969.      * <p>

  970.      * @param option - Option code.

  971.      ***/

  972.     final synchronized void _sendWill(int option)

  973.     throws IOException

  974.     {

  975.         if (debug || debugoptions)

  976.         {

  977.             System.err.println("WILL: " + TelnetOption.getOption(option));

  978.         }

  979.         _output_.write(_COMMAND_WILL);

  980.         _output_.write(option);

  981. 

  982.         /* Code Section added for sending the negotiation ASAP (start)*/

  983.         _output_.flush();

  984.         /* Code Section added for sending the negotiation ASAP (end)*/

  985.     }

  986. 

  987.     /***

  988.      * Requests a WILL.

  989.      * <p>

  990.      * @throws IOException - Exception in I/O.

  991.      * <p>

  992.      * @param option - Option code.

  993.      ***/

  994.     final synchronized void _requestWill(int option)

  995.     throws IOException

  996.     {

  997.         if ((_willResponse[option] == 0 && _stateIsWill(option))

  998.             || _requestedWill(option))

  999.         {

  1000.             return ;

  1001.         }

  1002.         _setWantWill(option);

  1003.         ++_doResponse[option];

  1004.         _sendWill(option);

  1005.     }

  1006. 

  1007.     /***

  1008.      * Sends a WONT.

  1009.      * <p>

  1010.      * @throws IOException - Exception in I/O.

  1011.      * <p>

  1012.      * @param option - Option code.

  1013.      ***/

  1014.     final synchronized void _sendWont(int option)

  1015.     throws IOException

  1016.     {

  1017.         if (debug || debugoptions)

  1018.         {

  1019.             System.err.println("WONT: " + TelnetOption.getOption(option));

  1020.         }

  1021.         _output_.write(_COMMAND_WONT);

  1022.         _output_.write(option);

  1023. 

  1024.         /* Code Section added for sending the negotiation ASAP (start)*/

  1025.         _output_.flush();

  1026.         /* Code Section added for sending the negotiation ASAP (end)*/

  1027.     }

  1028. 

  1029.     /***

  1030.      * Requests a WONT.

  1031.      * <p>

  1032.      * @throws IOException - Exception in I/O.

  1033.      * <p>

  1034.      * @param option - Option code.

  1035.      ***/

  1036.     final synchronized void _requestWont(int option)

  1037.     throws IOException

  1038.     {

  1039.         if ((_willResponse[option] == 0 && _stateIsWont(option))

  1040.             || _requestedWont(option))

  1041.         {

  1042.             return ;

  1043.         }

  1044.         _setWantWont(option);

  1045.         ++_doResponse[option];

  1046.         _sendWont(option);

  1047.     }

  1048. 

  1049.     /***

  1050.      * Sends a byte.

  1051.      * <p>

  1052.      * @throws IOException - Exception in I/O.

  1053.      * <p>

  1054.      * @param b - byte to send

  1055.      ***/

  1056.     final synchronized void _sendByte(int b)

  1057.     throws IOException

  1058.     {

  1059.         _output_.write(b);

  1060. 

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

  1062.         _spyWrite(b);

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

  1064. 

  1065.     }

  1066. 

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

  1068.     /***

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

  1070.      * <p>

  1071.      * @throws IOException - Exception in I/O.

  1072.      * @throws IllegalArgumentException - Illegal argument

  1073.      * @throws InterruptedException - Interrupted during wait.

  1074.      * <p>

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

  1076.      * <p>

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

  1078.      ***/

  1079.     final boolean _sendAYT(long timeout)

  1080.     throws IOException, IllegalArgumentException, InterruptedException

  1081.     {

  1082.         boolean retValue = false;

  1083.         synchronized (aytMonitor)

  1084.         {

  1085.             synchronized (this)

  1086.             {

  1087.                 aytFlag = false;

  1088.                 _output_.write(_COMMAND_AYT);

  1089.                 _output_.flush();

  1090.             }

  1091. 

  1092.             try

  1093.             {

  1094.                 aytMonitor.wait(timeout);

  1095.                 if (aytFlag == false)

  1096.                 {

  1097.                     retValue = false;

  1098.                     aytFlag = true;

  1099.                 }

  1100.                 else

  1101.                 {

  1102.                     retValue = true;

  1103.                 }

  1104.             }

  1105.             catch (IllegalMonitorStateException e)

  1106.             {

  1107.                 System.err.println("Exception processing AYT:"

  1108.                     + e.getMessage());

  1109.             }

  1110.         }

  1111. 

  1112.         return (retValue);

  1113.     }

  1114.     /* Code Section added for supporting AYT (end)*/

  1115. 

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

  1117. 

  1118.     /***

  1119.      * Registers a new TelnetOptionHandler for this telnet  to use.

  1120.      * <p>

  1121.      * @throws InvalidTelnetOptionException - The option code is invalid.

  1122.      * <p>

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

  1124.      ***/

  1125.     void addOptionHandler(TelnetOptionHandler opthand)

  1126.     throws InvalidTelnetOptionException

  1127.     {

  1128.         int optcode = opthand.getOptionCode();

  1129.         if (TelnetOption.isValidOption(optcode))

  1130.         {

  1131.             if (optionHandlers[optcode] == null)

  1132.             {

  1133.                 optionHandlers[optcode] = opthand;

  1134.                 if (isConnected())

  1135.                 {

  1136.                     if (opthand.getInitLocal())

  1137.                     {

  1138.                         try

  1139.                         {

  1140.                             _requestWill(optcode);

  1141.                         }

  1142.                         catch (IOException e)

  1143.                         {

  1144.                             System.err.println(

  1145.                                 "Exception while initializing option: "

  1146.                                 + e.getMessage());

  1147.                         }

  1148.                     }

  1149. 

  1150.                     if (opthand.getInitRemote())

  1151.                     {

  1152.                         try

  1153.                         {

  1154.                             _requestDo(optcode);

  1155.                         }

  1156.                         catch (IOException e)

  1157.                         {

  1158.                             System.err.println(

  1159.                                 "Exception while initializing option: "

  1160.                                 + e.getMessage());

  1161.                         }

  1162.                     }

  1163.                 }

  1164.             }

  1165.             else

  1166.             {

  1167.                 throw (new InvalidTelnetOptionException(

  1168.                     "Already registered option", optcode));

  1169.             }

  1170.         }

  1171.         else

  1172.         {

  1173.             throw (new InvalidTelnetOptionException(

  1174.                 "Invalid Option Code", optcode));

  1175.         }

  1176.     }

  1177. 

  1178.     /***

  1179.      * Unregisters a  TelnetOptionHandler.

  1180.      * <p>

  1181.      * @throws InvalidTelnetOptionException - The option code is invalid.

  1182.      * <p>

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

  1184.      ***/

  1185.     void deleteOptionHandler(int optcode)

  1186.     throws InvalidTelnetOptionException

  1187.     {

  1188.         if (TelnetOption.isValidOption(optcode))

  1189.         {

  1190.             if (optionHandlers[optcode] == null)

  1191.             {

  1192.                 throw (new InvalidTelnetOptionException(

  1193.                     "Unregistered option", optcode));

  1194.             }

  1195.             else

  1196.             {

  1197.                 TelnetOptionHandler opthand = optionHandlers[optcode];

  1198.                 optionHandlers[optcode] = null;

  1199. 

  1200.                 if (opthand.getWill())

  1201.                 {

  1202.                     try

  1203.                     {

  1204.                         _requestWont(optcode);

  1205.                     }

  1206.                     catch (IOException e)

  1207.                     {

  1208.                         System.err.println(

  1209.                             "Exception while turning off option: "

  1210.                             + e.getMessage());

  1211.                     }

  1212.                 }

  1213. 

  1214.                 if (opthand.getDo())

  1215.                 {

  1216.                     try

  1217.                     {

  1218.                         _requestDont(optcode);

  1219.                     }

  1220.                     catch (IOException e)

  1221.                     {

  1222.                         System.err.println(

  1223.                             "Exception while turning off option: "

  1224.                             + e.getMessage());

  1225.                     }

  1226.                 }

  1227.             }

  1228.         }

  1229.         else

  1230.         {

  1231.             throw (new InvalidTelnetOptionException(

  1232.                 "Invalid Option Code", optcode));

  1233.         }

  1234.     }

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

  1236. 

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

  1238.     /***

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

  1240.      * the Telnet session.

  1241.      * <p>

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

  1243.      * will be echoed.

  1244.      ***/

  1245.     void _registerSpyStream(OutputStream  spystream)

  1246.     {

  1247.         spyStream = spystream;

  1248.     }

  1249. 

  1250.     /***

  1251.      * Stops spying this Telnet.

  1252.      * <p>

  1253.      ***/

  1254.     void _stopSpyStream()

  1255.     {

  1256.         spyStream = null;

  1257.     }

  1258. 

  1259.     /***

  1260.      * Sends a read char on the spy stream.

  1261.      * <p>

  1262.      * @param ch - character read from the session

  1263.      ***/

  1264.     void _spyRead(int ch)

  1265.     {

  1266.         if (spyStream != null)

  1267.         {

  1268.             try

  1269.             {

  1270.                 if (ch != (int) '\r')

  1271.                 {

  1272.                     spyStream.write(ch);

  1273.                     if (ch == (int) '\n')

  1274.                     {

  1275.                         spyStream.write((int) '\r');

  1276.                     }

  1277.                     spyStream.flush();

  1278.                 }

  1279.             }

  1280.             catch (Exception e)

  1281.             {

  1282.                 spyStream = null;

  1283.             }

  1284.         }

  1285.     }

  1286. 

  1287.     /***

  1288.      * Sends a written char on the spy stream.

  1289.      * <p>

  1290.      * @param ch - character written to the session

  1291.      ***/

  1292.     void _spyWrite(int ch)

  1293.     {

  1294.         if (!(_stateIsDo(TelnetOption.ECHO)

  1295.             && _requestedDo(TelnetOption.ECHO)))

  1296.         {

  1297.             if (spyStream != null)

  1298.             {

  1299.                 try

  1300.                 {

  1301.                     spyStream.write(ch);

  1302.                     spyStream.flush();

  1303.                 }

  1304.                 catch (Exception e)

  1305.                 {

  1306.                     spyStream = null;

  1307.                 }

  1308.             }

  1309.         }

  1310.     }

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

  1312. 

  1313.     /***

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

  1315.      * notifications of received telnet option negotiation commands.

  1316.      * <p>

  1317.      * @param notifhand - TelnetNotificationHandler to be registered

  1318.      ***/

  1319.     public void registerNotifHandler(TelnetNotificationHandler  notifhand)

  1320.     {

  1321.         __notifhand = notifhand;

  1322.     }

  1323. 

  1324.     /***

  1325.      * Unregisters the current notification handler.

  1326.      * <p>

  1327.      ***/

  1328.     public void unregisterNotifHandler()

  1329.     {

  1330.         __notifhand = null;

  1331.     }

  1332. }