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