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.io.OutputStreamWriter;
23  import java.io.PrintWriter;
24  import java.net.InetAddress;
25  import java.net.SocketException;
26  import org.apache.commons.net.EchoTCPClient;
27  import org.apache.commons.net.EchoUDPClient;
28  
29  /***
30   * This is an example program demonstrating how to use the EchoTCPClient
31   * and EchoUDPClient classes.  This program connects to the default echo
32   * service port of a specified server, then reads lines from standard
33   * input, writing them to the echo server, and then printing the echo.
34   * The default is to use the TCP port.  Use the -udp flag to use the UDP
35   * port.
36   * <p>
37   * Usage: echo [-udp] <hostname>
38   * <p>
39   ***/
40  public final class echo
41  {
42  
43      public static final void echoTCP(String host) throws IOException
44      {
45          EchoTCPClient client = new EchoTCPClient();
46          BufferedReader input, echoInput;
47          PrintWriter echoOutput;
48          String line;
49  
50          // We want to timeout if a response takes longer than 60 seconds
51          client.setDefaultTimeout(60000);
52          client.connect(host);
53          System.out.println("Connected to " + host + ".");
54          input = new BufferedReader(new InputStreamReader(System.in));
55          echoOutput =
56              new PrintWriter(new OutputStreamWriter(client.getOutputStream()), true);
57          echoInput =
58              new BufferedReader(new InputStreamReader(client.getInputStream()));
59  
60          while ((line = input.readLine()) != null)
61          {
62              echoOutput.println(line);
63              System.out.println(echoInput.readLine());
64          }
65  
66          client.disconnect();
67      }
68  
69      public static final void echoUDP(String host) throws IOException
70      {
71          int length, count;
72          byte[] data;
73          String line;
74          BufferedReader input;
75          InetAddress address;
76          EchoUDPClient client;
77  
78          input = new BufferedReader(new InputStreamReader(System.in));
79          address = InetAddress.getByName(host);
80          client = new EchoUDPClient();
81  
82          client.open();
83          // If we don't receive an echo within 5 seconds, assume the packet is lost.
84          client.setSoTimeout(5000);
85          System.out.println("Ready to echo to " + host + ".");
86  
87          // Remember, there are no guarantees about the ordering of returned
88          // UDP packets, so there is a chance the output may be jumbled.
89          while ((line = input.readLine()) != null)
90          {
91              data = line.getBytes();
92              client.send(data, address);
93              count = 0;
94              do
95              {
96                  try
97                  {
98                      length = client.receive(data);
99                  }
100                 // Here we catch both SocketException and InterruptedIOException,
101                 // because even though the JDK 1.1 docs claim that
102                 // InterruptedIOException is thrown on a timeout, it seems
103                 // SocketException is also thrown.
104                 catch (SocketException e)
105                 {
106                     // We timed out and assume the packet is lost.
107                     System.err.println(
108                         "SocketException: Timed out and dropped packet");
109                     break;
110                 }
111                 catch (InterruptedIOException e)
112                 {
113                     // We timed out and assume the packet is lost.
114                     System.err.println(
115                         "InterruptedIOException: Timed out and dropped packet");
116                     break;
117                 }
118                 System.out.print(new String(data, 0, length));
119                 count += length;
120             }
121             while (count < data.length);
122 
123             System.out.println();
124         }
125 
126         client.close();
127     }
128 
129 
130     public static final void main(String[] args)
131     {
132 
133         if (args.length == 1)
134         {
135             try
136             {
137                 echoTCP(args[0]);
138             }
139             catch (IOException e)
140             {
141                 e.printStackTrace();
142                 System.exit(1);
143             }
144         }
145         else if (args.length == 2 && args[0].equals("-udp"))
146         {
147             try
148             {
149                 echoUDP(args[1]);
150             }
151             catch (IOException e)
152             {
153                 e.printStackTrace();
154                 System.exit(1);
155             }
156         }
157         else
158         {
159             System.err.println("Usage: echo [-udp] <hostname>");
160             System.exit(1);
161         }
162 
163     }
164 
165 }
166