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. 

  18. import java.io.BufferedInputStream;

  19. import java.io.IOException;

  20. import java.io.InputStream;

  21. import java.io.InterruptedIOException;

  22. 

  23. /***

  24.  *

  25.  * <p>

  26.  *

  27.  * <p>

  28.  * <p>

  29.  * @author Daniel F. Savarese

  30.  * @author Bruno D'Avanzo

  31.  ***/

  32. 

  33. 

  34. final class TelnetInputStream extends BufferedInputStream implements Runnable

  35. {

  36.     static final int _STATE_DATA = 0, _STATE_IAC = 1, _STATE_WILL = 2,

  37.                      _STATE_WONT = 3, _STATE_DO = 4, _STATE_DONT = 5,

  38.                      _STATE_SB = 6, _STATE_SE = 7, _STATE_CR = 8, _STATE_IAC_SB = 9;

  39. 

  40.     private boolean __hasReachedEOF, __isClosed;

  41.     private boolean __readIsWaiting;

  42.     private int __receiveState, __queueHead, __queueTail, __bytesAvailable;

  43.     private int[] __queue;

  44.     private TelnetClient __client;

  45.     private Thread __thread;

  46.     private IOException __ioException;

  47. 

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

  49.     private int __suboption[] = new int[256];

  50.     private int __suboption_count = 0;

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

  52. 

  53.     private boolean _ayt_flag = false;

  54. 

  55.     private boolean __threaded = false;

  56.     TelnetInputStream(InputStream input, TelnetClient client)

  57.     {

  58.         super(input);

  59.         __client = client;

  60.         __receiveState = _STATE_DATA;

  61.         __isClosed = true;

  62.         __hasReachedEOF = false;

  63.         // Make it 1025, because when full, one slot will go unused, and we

  64.         // want a 1024 byte buffer just to have a round number (base 2 that is)

  65.         //__queue         = new int[1025];

  66.         __queue = new int[2049];

  67.         __queueHead = 0;

  68.         __queueTail = 0;

  69.         __bytesAvailable = 0;

  70.         __ioException = null;

  71.         __readIsWaiting = false;

  72.         __thread = new Thread(this);

  73.     }

  74. 

  75.     void _start()

  76.     {

  77.         int priority;

  78.         __isClosed = false;

  79.         // Need to set a higher priority in case JVM does not use pre-emptive

  80.         // threads.  This should prevent scheduler induced deadlock (rather than

  81.         // deadlock caused by a bug in this code).

  82.         priority = Thread.currentThread().getPriority() + 1;

  83.         if (priority > Thread.MAX_PRIORITY)

  84.             priority = Thread.MAX_PRIORITY;

  85.         __thread.setPriority(priority);

  86.         __thread.setDaemon(true);

  87.         __thread.start();

  88.         __threaded = true;

  89.     }

  90. 

  91. 

  92.     // synchronized(__client) critical sections are to protect against

  93.     // TelnetOutputStream writing through the telnet client at same time

  94.     // as a processDo/Will/etc. command invoked from TelnetInputStream

  95.     // tries to write.

  96.     private int __read() throws IOException

  97.     {

  98.         int ch;

  99. 

  100. _loop:

  101.         while (true)

  102.         {

  103.             // Exit only when we reach end of stream.

  104.             if ((ch = super.read()) < 0)

  105.                 return -1;

  106. 

  107.             ch = (ch & 0xff);

  108. 

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

  110.             synchronized (__client)

  111.             {

  112.                 __client._processAYTResponse();

  113.             }

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

  115. 

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

  117.             __client._spyRead(ch);

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

  119. 

  120. _mainSwitch:

  121.             switch (__receiveState)

  122.             {

  123. 

  124.             case _STATE_CR:

  125.                 if (ch == '\0')

  126.                 {

  127.                     // Strip null

  128.                     continue;

  129.                 }

  130.                 // How do we handle newline after cr?

  131.                 //  else if (ch == '\n' && _requestedDont(TelnetOption.ECHO) &&

  132. 

  133.                 // Handle as normal data by falling through to _STATE_DATA case

  134. 

  135.             case _STATE_DATA:

  136.                 if (ch == TelnetCommand.IAC)

  137.                 {

  138.                     __receiveState = _STATE_IAC;

  139.                     continue;

  140.                 }

  141. 

  142. 

  143.                 if (ch == '\r')

  144.                 {

  145.                     synchronized (__client)

  146.                     {

  147.                         if (__client._requestedDont(TelnetOption.BINARY))

  148.                             __receiveState = _STATE_CR;

  149.                         else

  150.                             __receiveState = _STATE_DATA;

  151.                     }

  152.                 }

  153.                 else

  154.                     __receiveState = _STATE_DATA;

  155.                 break;

  156. 

  157.             case _STATE_IAC:

  158.                 switch (ch)

  159.                 {

  160.                 case TelnetCommand.WILL:

  161.                     __receiveState = _STATE_WILL;

  162.                     continue;

  163.                 case TelnetCommand.WONT:

  164.                     __receiveState = _STATE_WONT;

  165.                     continue;

  166.                 case TelnetCommand.DO:

  167.                     __receiveState = _STATE_DO;

  168.                     continue;

  169.                 case TelnetCommand.DONT:

  170.                     __receiveState = _STATE_DONT;

  171.                     continue;

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

  173.                 case TelnetCommand.SB:

  174.                     __suboption_count = 0;

  175.                     __receiveState = _STATE_SB;

  176.                     continue;

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

  178.                 case TelnetCommand.IAC:

  179.                     __receiveState = _STATE_DATA;

  180.                     break;

  181.                 default:

  182.                     break;

  183.                 }

  184.                 __receiveState = _STATE_DATA;

  185.                 continue;

  186.             case _STATE_WILL:

  187.                 synchronized (__client)

  188.                 {

  189.                     __client._processWill(ch);

  190.                     __client._flushOutputStream();

  191.                 }

  192.                 __receiveState = _STATE_DATA;

  193.                 continue;

  194.             case _STATE_WONT:

  195.                 synchronized (__client)

  196.                 {

  197.                     __client._processWont(ch);

  198.                     __client._flushOutputStream();

  199.                 }

  200.                 __receiveState = _STATE_DATA;

  201.                 continue;

  202.             case _STATE_DO:

  203.                 synchronized (__client)

  204.                 {

  205.                     __client._processDo(ch);

  206.                     __client._flushOutputStream();

  207.                 }

  208.                 __receiveState = _STATE_DATA;

  209.                 continue;

  210.             case _STATE_DONT:

  211.                 synchronized (__client)

  212.                 {

  213.                     __client._processDont(ch);

  214.                     __client._flushOutputStream();

  215.                 }

  216.                 __receiveState = _STATE_DATA;

  217.                 continue;

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

  219.             case _STATE_SB:

  220.                 switch (ch)

  221.                 {

  222.                 case TelnetCommand.IAC:

  223.                     __receiveState = _STATE_IAC_SB;

  224.                     continue;

  225.                 default:

  226.                     // store suboption char

  227.                     __suboption[__suboption_count++] = ch;

  228.                     break;

  229.                 }

  230.                 __receiveState = _STATE_SB;

  231.                 continue;

  232.             case _STATE_IAC_SB:

  233.                 switch (ch)

  234.                 {

  235.                 case TelnetCommand.SE:

  236.                     synchronized (__client)

  237.                     {

  238.                         __client._processSuboption(__suboption, __suboption_count);

  239.                         __client._flushOutputStream();

  240.                     }

  241.                     __receiveState = _STATE_DATA;

  242.                     continue;

  243.                 default:

  244.                     __receiveState = _STATE_SB;

  245.                     break;

  246.                 }

  247.                 __receiveState = _STATE_DATA;

  248.                 continue;

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

  250.             }

  251. 

  252.             break;

  253.         }

  254. 

  255.         return ch;

  256.     }

  257. 

  258.     // synchronized(__client) critical sections are to protect against

  259.     // TelnetOutputStream writing through the telnet client at same time

  260.     // as a processDo/Will/etc. command invoked from TelnetInputStream

  261.     // tries to write.

  262.     private void __processChar(int ch) throws InterruptedException

  263.     {

  264.         // Critical section because we're altering __bytesAvailable,

  265.         // __queueTail, and the contents of _queue.

  266.         synchronized (__queue)

  267.         {

  268.             while (__bytesAvailable >= __queue.length - 1)

  269.             {

  270.                 if(__threaded)

  271.                 {

  272.                     __queue.notify();

  273.                     try

  274.                     {

  275.                         __queue.wait();

  276.                     }

  277.                     catch (InterruptedException e)

  278.                     {

  279.                         throw e;

  280.                     }

  281.                 }

  282.             }

  283. 

  284.             // Need to do this in case we're not full, but block on a read

  285.             if (__readIsWaiting && __threaded)

  286.             {

  287.                 __queue.notify();

  288.             }

  289. 

  290.             __queue[__queueTail] = ch;

  291.             ++__bytesAvailable;

  292. 

  293.             if (++__queueTail >= __queue.length)

  294.                 __queueTail = 0;

  295.         }

  296.     }

  297. 

  298.     public int read() throws IOException

  299.     {

  300.         // Critical section because we're altering __bytesAvailable,

  301.         // __queueHead, and the contents of _queue in addition to

  302.         // testing value of __hasReachedEOF.

  303.         synchronized (__queue)

  304.         {

  305. 

  306.             while (true)

  307.             {

  308.                 if (__ioException != null)

  309.                 {

  310.                     IOException e;

  311.                     e = __ioException;

  312.                     __ioException = null;

  313.                     throw e;

  314.                 }

  315. 

  316.                 if (__bytesAvailable == 0)

  317.                 {

  318.                     // Return -1 if at end of file

  319.                     if (__hasReachedEOF)

  320.                         return -1;

  321. 

  322.                     // Otherwise, we have to wait for queue to get something

  323.                     if(__threaded)

  324.                     {

  325.                         __queue.notify();

  326.                         try

  327.                         {

  328.                             __readIsWaiting = true;

  329.                             __queue.wait();

  330.                             __readIsWaiting = false;

  331.                         }

  332.                         catch (InterruptedException e)

  333.                         {

  334.                             throw new IOException("Fatal thread interruption during read.");

  335.                         }

  336.                     }

  337.                     else

  338.                     {

  339.                         //__alreadyread = false;

  340.                         __readIsWaiting = true;

  341.                         int ch;

  342. 

  343.                         do

  344.                         {

  345.                             try

  346.                             {

  347.                                 if ((ch = __read()) < 0)

  348.                                     if(ch != -2)

  349.                                         return (ch);

  350.                             }

  351.                             catch (InterruptedIOException e)

  352.                             {

  353.                                 synchronized (__queue)

  354.                                 {

  355.                                     __ioException = e;

  356.                                     __queue.notifyAll();

  357.                                     try

  358.                                     {

  359.                                         __queue.wait(100);

  360.                                     }

  361.                                     catch (InterruptedException interrupted)

  362.                                     {

  363.                                     }

  364.                                 }

  365.                                 return (-1);

  366.                             }

  367. 

  368. 

  369.                             try

  370.                             {

  371.                                 if(ch != -2)

  372.                                 {

  373.                                     __processChar(ch);

  374.                                 }

  375.                             }

  376.                             catch (InterruptedException e)

  377.                             {

  378.                                 if (__isClosed)

  379.                                     return (-1);

  380.                             }

  381.                         }

  382.                         while (super.available() > 0);

  383. 

  384.                         __readIsWaiting = false;

  385.                     }

  386.                     continue;

  387.                 }

  388.                 else

  389.                 {

  390.                     int ch;

  391. 

  392.                     ch = __queue[__queueHead];

  393. 

  394.                     if (++__queueHead >= __queue.length)

  395.                         __queueHead = 0;

  396. 

  397.                     --__bytesAvailable;

  398. 

  399.                     return ch;

  400.                 }

  401.             }

  402.         }

  403.     }

  404. 

  405. 

  406.     /***

  407.      * Reads the next number of bytes from the stream into an array and

  408.      * returns the number of bytes read.  Returns -1 if the end of the

  409.      * stream has been reached.

  410.      * <p>

  411.      * @param buffer  The byte array in which to store the data.

  412.      * @return The number of bytes read. Returns -1 if the

  413.      *          end of the message has been reached.

  414.      * @exception IOException If an error occurs in reading the underlying

  415.      *            stream.

  416.      ***/

  417.     public int read(byte buffer[]) throws IOException

  418.     {

  419.         return read(buffer, 0, buffer.length);

  420.     }

  421. 

  422. 

  423.     /***

  424.      * Reads the next number of bytes from the stream into an array and returns

  425.      * the number of bytes read.  Returns -1 if the end of the

  426.      * message has been reached.  The characters are stored in the array

  427.      * starting from the given offset and up to the length specified.

  428.      * <p>

  429.      * @param buffer The byte array in which to store the data.

  430.      * @param offset  The offset into the array at which to start storing data.

  431.      * @param length   The number of bytes to read.

  432.      * @return The number of bytes read. Returns -1 if the

  433.      *          end of the stream has been reached.

  434.      * @exception IOException If an error occurs while reading the underlying

  435.      *            stream.

  436.      ***/

  437.     public int read(byte buffer[], int offset, int length) throws IOException

  438.     {

  439.         int ch, off;

  440. 

  441.         if (length < 1)

  442.             return 0;

  443. 

  444.         // Critical section because run() may change __bytesAvailable

  445.         synchronized (__queue)

  446.         {

  447.             if (length > __bytesAvailable)

  448.                 length = __bytesAvailable;

  449.         }

  450. 

  451.         if ((ch = read()) == -1)

  452.             return -1;

  453. 

  454.         off = offset;

  455. 

  456.         do

  457.         {

  458.             buffer[offset++] = (byte)ch;

  459.         }

  460.         while (--length > 0 && (ch = read()) != -1);

  461. 

  462.         //__client._spyRead(buffer, off, offset - off);

  463.         return (offset - off);

  464.     }

  465. 

  466. 

  467.     /*** Returns false.  Mark is not supported. ***/

  468.     public boolean markSupported()

  469.     {

  470.         return false;

  471.     }

  472. 

  473.     public int available() throws IOException

  474.     {

  475.         // Critical section because run() may change __bytesAvailable

  476.         synchronized (__queue)

  477.         {

  478.             return __bytesAvailable;

  479.         }

  480.     }

  481. 

  482. 

  483.     // Cannot be synchronized.  Will cause deadlock if run() is blocked

  484.     // in read because BufferedInputStream read() is synchronized.

  485.     public void close() throws IOException

  486.     {

  487.         // Completely disregard the fact thread may still be running.

  488.         // We can't afford to block on this close by waiting for

  489.         // thread to terminate because few if any JVM's will actually

  490.         // interrupt a system read() from the interrupt() method.

  491.         super.close();

  492. 

  493.         synchronized (__queue)

  494.         {

  495.             __hasReachedEOF = true;

  496.             __isClosed      = true;

  497. 

  498.             if (__thread.isAlive())

  499.             {

  500.                 __thread.interrupt();

  501.             }

  502. 

  503.             __queue.notifyAll();

  504.         }

  505. 

  506.         __threaded = false;

  507.     }

  508. 

  509.     public void run()

  510.     {

  511.         int ch;

  512. 

  513.         try

  514.         {

  515. _outerLoop:

  516.             while (!__isClosed)

  517.             {

  518.                 try

  519.                 {

  520.                     if ((ch = __read()) < 0)

  521.                         break;

  522.                 }

  523.                 catch (InterruptedIOException e)

  524.                 {

  525.                     synchronized (__queue)

  526.                     {

  527.                         __ioException = e;

  528.                         __queue.notifyAll();

  529.                         try

  530.                         {

  531.                             __queue.wait(100);

  532.                         }

  533.                         catch (InterruptedException interrupted)

  534.                         {

  535.                             if (__isClosed)

  536.                                 break _outerLoop;

  537.                         }

  538.                         continue;

  539.                     }

  540.                 } catch(RuntimeException re) {

  541.                     // We treat any runtime exceptions as though the

  542.                     // stream has been closed.  We close the

  543.                     // underlying stream just to be sure.

  544.                     super.close();

  545.                     // Breaking the loop has the effect of setting

  546.                     // the state to closed at the end of the method.

  547.                     break _outerLoop;

  548.                 }

  549. 

  550.                 try

  551.                 {

  552.                     __processChar(ch);

  553.                 }

  554.                 catch (InterruptedException e)

  555.                 {

  556.                     if (__isClosed)

  557.                         break _outerLoop;

  558.                 }

  559.             }

  560.         }

  561.         catch (IOException ioe)

  562.         {

  563.             synchronized (__queue)

  564.             {

  565.                 __ioException = ioe;

  566.             }

  567.         }

  568. 

  569.         synchronized (__queue)

  570.         {

  571.             __isClosed      = true; // Possibly redundant

  572.             __hasReachedEOF = true;

  573.             __queue.notify();

  574.         }

  575. 

  576.         __threaded = false;

  577.     }

  578. }

  579. 

  580. /* Emacs configuration

  581.  * Local variables:        **

  582.  * mode:             java  **

  583.  * c-basic-offset:   4     **

  584.  * indent-tabs-mode: nil   **

  585.  * End:                    **

  586.  */