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 examples;
    17
    18  import java.io.BufferedReader;
    19  import java.io.IOException;
    20  import java.io.InputStreamReader;
    21  import java.io.InterruptedIOException;
    22  import java.net.InetAddress;
    23  import java.net.SocketException;
    24  import org.apache.commons.net.CharGenTCPClient;
    25  import org.apache.commons.net.CharGenUDPClient;
    26
    27  /****
    28   * This is an example program demonstrating how to use the CharGenTCPClient
    29   * and CharGenUDPClient classes.  This program connects to the default
    30   * chargen service port of a specified server, then reads 100 lines from
    31   * of generated output, writing each line to standard output, and then
    32   * closes the connection.  The UDP invocation of the program sends 50
    33   * datagrams, printing the reply to each.
    34   * The default is to use the TCP port.  Use the -udp flag to use the UDP
    35   * port.
    36   * <p>
    37   * Usage: chargen [-udp] <hostname>
    38   * <p>
    39   ***/
    40  public final class chargen
    41  {
    42
    43      public static final void chargenTCP(String host) throws IOException
    44      {
    45          int lines = 100;
    46          String line;
    47          CharGenTCPClient client = new CharGenTCPClient();
    48          BufferedReader chargenInput;
    49
    50          // We want to timeout if a response takes longer than 60 seconds
    51          client.setDefaultTimeout(60000);
    52          client.connect(host);
    53          chargenInput =
    54              new BufferedReader(new InputStreamReader(client.getInputStream()));
    55
    56          // We assume the chargen service outputs lines, but it really doesn't
    57          // have to, so this code might actually not work if no newlines are
    58          // present.
    59          while (lines-- > 0)
    60          {
    61              if ((line = chargenInput.readLine()) == null)
    62                  break;
    63              System.out.println(line);
    64          }
    65
    66          client.disconnect();
    67      }
    68
    69      public static final void chargenUDP(String host) throws IOException
    70      {
    71          int packets = 50;
    72          byte[] data;
    73          InetAddress address;
    74          CharGenUDPClient client;
    75
    76          address = InetAddress.getByName(host);
    77          client = new CharGenUDPClient();
    78
    79          client.open();
    80          // If we don't receive a return packet within 5 seconds, assume
    81          // the packet is lost.
    82          client.setSoTimeout(5000);
    83
    84          while (packets-- > 0)
    85          {
    86              client.send(address);
    87
    88              try
    89              {
    90                  data = client.receive();
    91              }
    92              // Here we catch both SocketException and InterruptedIOException,
    93              // because even though the JDK 1.1 docs claim that
    94              // InterruptedIOException is thrown on a timeout, it seems
    95              // SocketException is also thrown.
    96              catch (SocketException e)
    97              {
    98                  // We timed out and assume the packet is lost.
    99                  System.err.println("SocketException: Timed out and dropped packet");
    100                 continue;
    101             }
    102             catch (InterruptedIOException e)
    103             {
    104                 // We timed out and assume the packet is lost.
    105                 System.err.println(
    106                     "InterruptedIOException: Timed out and dropped packet");
    107                 continue;
    108             }
    109             System.out.write(data);
    110             System.out.flush();
    111         }
    112
    113         client.close();
    114     }
    115
    116
    117     public static final void main(String[] args)
    118     {
    119
    120         if (args.length == 1)
    121         {
    122             try
    123             {
    124                 chargenTCP(args[0]);
    125             }
    126             catch (IOException e)
    127             {
    128                 e.printStackTrace();
    129                 System.exit(1);
    130             }
    131         }
    132         else if (args.length == 2 && args[0].equals("-udp"))
    133         {
    134             try
    135             {
    136                 chargenUDP(args[1]);
    137             }
    138             catch (IOException e)
    139             {
    140                 e.printStackTrace();
    141                 System.exit(1);
    142             }
    143         }
    144         else
    145         {
    146             System.err.println("Usage: chargen [-udp] <hostname>");
    147             System.exit(1);
    148         }
    149
    150     }
    151
    152 }
    153