KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > examples > chargen


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 JavaDoc;
19 import java.io.IOException JavaDoc;
20 import java.io.InputStreamReader JavaDoc;
21 import java.io.InterruptedIOException JavaDoc;
22 import java.net.InetAddress JavaDoc;
23 import java.net.SocketException JavaDoc;
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 JavaDoc host) throws IOException JavaDoc
44     {
45         int lines = 100;
46         String JavaDoc line;
47         CharGenTCPClient client = new CharGenTCPClient();
48         BufferedReader JavaDoc 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 JavaDoc(new InputStreamReader JavaDoc(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 JavaDoc host) throws IOException JavaDoc
70     {
71         int packets = 50;
72         byte[] data;
73         InetAddress JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc[] args)
118     {
119
120         if (args.length == 1)
121         {
122             try
123             {
124                 chargenTCP(args[0]);
125             }
126             catch (IOException JavaDoc 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 JavaDoc 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
154
Popular Tags