View Javadoc

    1   /*
    2    * Copyright 2001-2005 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.IOException;
    19  import java.io.OutputStream;
    20
    21  /****
    22   *
    23   * <p>
    24   *
    25   * <p>
    26   * <p>
    27   * @author Daniel F. Savarese
    28   ***/
    29
    30
    31  final class TelnetOutputStream extends OutputStream
    32  {
    33      private TelnetClient __client;
    34      private boolean __convertCRtoCRLF = true;
    35      private boolean __lastWasCR = false;
    36
    37      TelnetOutputStream(TelnetClient client)
    38      {
    39          __client = client;
    40      }
    41
    42
    43      /****
    44       * Writes a byte to the stream.
    45       * <p>
    46       * @param ch The byte to write.
    47       * @exception IOException If an error occurs while writing to the underlying
    48       *            stream.
    49       ***/
    50      public void write(int ch) throws IOException
    51      {
    52
    53          synchronized (__client)
    54          {
    55              ch &= 0xff;
    56
    57              if (__client._requestedWont(TelnetOption.BINARY))
    58              {
    59                  if (__lastWasCR)
    60                  {
    61                      if (__convertCRtoCRLF)
    62                      {
    63                          __client._sendByte('\n');
    64                          if (ch == '\n')
    65                          {
    66                              __lastWasCR = false;
    67                              return ;
    68                          }
    69                      }
    70                      else if (ch != '\n')
    71                          __client._sendByte('\0');
    72                  }
    73
    74                  __lastWasCR = false;
    75
    76                  switch (ch)
    77                  {
    78                  case '\r':
    79                      __client._sendByte('\r');
    80                      __lastWasCR = true;
    81                      break;
    82                  case TelnetCommand.IAC:
    83                      __client._sendByte(TelnetCommand.IAC);
    84                      __client._sendByte(TelnetCommand.IAC);
    85                      break;
    86                  default:
    87                      __client._sendByte(ch);
    88                      break;
    89                  }
    90              }
    91              else if (ch == TelnetCommand.IAC)
    92              {
    93                  __client._sendByte(ch);
    94                  __client._sendByte(TelnetCommand.IAC);
    95              }
    96              else
    97                  __client._sendByte(ch);
    98          }
    99      }
    100
    101
    102     /****
    103      * Writes a byte array to the stream.
    104      * <p>
    105      * @param buffer  The byte array to write.
    106      * @exception IOException If an error occurs while writing to the underlying
    107      *            stream.
    108      ***/
    109     public void write(byte buffer[]) throws IOException
    110     {
    111         write(buffer, 0, buffer.length);
    112     }
    113
    114
    115     /****
    116      * Writes a number of bytes from a byte array to the stream starting from
    117      * a given offset.
    118      * <p>
    119      * @param buffer  The byte array to write.
    120      * @param offset  The offset into the array at which to start copying data.
    121      * @param length  The number of bytes to write.
    122      * @exception IOException If an error occurs while writing to the underlying
    123      *            stream.
    124      ***/
    125     public void write(byte buffer[], int offset, int length) throws IOException
    126     {
    127         synchronized (__client)
    128         {
    129             while (length-- > 0)
    130                 write(buffer[offset++]);
    131         }
    132     }
    133
    134     /**** Flushes the stream. ***/
    135     public void flush() throws IOException
    136     {
    137         __client._flushOutputStream();
    138     }
    139
    140     /**** Closes the stream. ***/
    141     public void close() throws IOException
    142     {
    143         __client._closeOutputStream();
    144     }
    145 }