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;
17  
18  import java.io.BufferedReader;
19  import java.io.IOException;
20  import java.io.InputStream;
21  import java.io.InputStreamReader;
22  import java.io.BufferedOutputStream;
23  import java.io.DataOutputStream;
24  
25  /***
26   * The FingerClient class implements the client side of the Internet Finger
27   * Protocol defined in RFC 1288.  To finger a host you create a
28   * FingerClient instance, connect to the host, query the host, and finally
29   * disconnect from the host.  If the finger service you want to query is on
30   * a non-standard port, connect to the host at that port.
31   * Here's a sample use:
32   * <pre>
33   *    FingerClient finger;
34   *
35   *    finger = new FingerClient();
36   *
37   *    try {
38   *      finger.connect("foo.bar.com");
39   *      System.out.println(finger.query("foobar", false));
40   *      finger.disconnect();
41   *    } catch(IOException e) {
42   *      System.err.println("Error I/O exception: " + e.getMessage());
43   *      return;
44   *    }
45   * </pre>
46   * <p>
47   * <p>
48   * @author Daniel F. Savarese
49   ***/
50  
51  public class FingerClient extends SocketClient
52  {
53      /***
54       * The default FINGER port.  Set to 79 according to RFC 1288.
55       ***/
56      public static final int DEFAULT_PORT = 79;
57  
58      private static final String __LONG_FLAG = "/W ";
59  
60      private transient StringBuffer __query = new StringBuffer(64);
61      private transient char[] __buffer = new char[1024];
62  
63      /***
64       * The default FingerClient constructor.  Initializes the
65       * default port to <code> DEFAULT_PORT </code>.
66       ***/
67      public FingerClient()
68      {
69          setDefaultPort(DEFAULT_PORT);
70      }
71  
72  
73      /***
74       * Fingers a user at the connected host and returns the output
75       * as a String.  You must first connect to a finger server before
76       * calling this method, and you should disconnect afterward.
77       * <p>
78       * @param longOutput Set to true if long output is requested, false if not.
79       * @param username  The name of the user to finger.
80       * @return The result of the finger query.
81       * @exception IOException If an I/O error occurs while reading the socket.
82       ***/
83      public String query(boolean longOutput, String username) throws IOException
84      {
85          int read;
86          StringBuffer result = new StringBuffer(__buffer.length);
87          BufferedReader input;
88  
89          input =
90              new BufferedReader(new InputStreamReader(getInputStream(longOutput,
91                                 username)));
92  
93          while (true)
94          {
95              read = input.read(__buffer, 0, __buffer.length);
96              if (read <= 0)
97                  break;
98              result.append(__buffer, 0, read);
99          }
100 
101         input.close();
102 
103         return result.toString();
104     }
105 
106 
107     /***
108      * Fingers the connected host and returns the output
109      * as a String.  You must first connect to a finger server before
110      * calling this method, and you should disconnect afterward.
111      * This is equivalent to calling <code> query(longOutput, "") </code>.
112      * <p>
113      * @param longOutput Set to true if long output is requested, false if not.
114      * @return The result of the finger query.
115      * @exception IOException If an I/O error occurs while reading the socket.
116      ***/
117     public String query(boolean longOutput) throws IOException
118     {
119         return query(longOutput, "");
120     }
121 
122 
123     /***
124      * Fingers a user and returns the input stream from the network connection
125      * of the finger query.  You must first connect to a finger server before
126      * calling this method, and you should disconnect after finishing reading
127      * the stream.
128      * <p>
129      * @param longOutput Set to true if long output is requested, false if not.
130      * @param username  The name of the user to finger.
131      * @return The InputStream of the network connection of the finger query.
132      *         Can be read to obtain finger results.
133      * @exception IOException If an I/O error during the operation.
134      ***/
135     public InputStream getInputStream(boolean longOutput, String username)
136     throws IOException
137     {
138         DataOutputStream output;
139 
140         __query.setLength(0);
141         if (longOutput)
142             __query.append(__LONG_FLAG);
143         __query.append(username);
144         __query.append(SocketClient.NETASCII_EOL);
145 
146         output =
147           new DataOutputStream(new BufferedOutputStream(_output_, 1024));
148         output.writeBytes(__query.toString());
149         output.flush();
150 
151         return _input_;
152     }
153 
154 
155     /***
156      * Fingers the connected host and returns the input stream from
157      * the network connection of the finger query.  This is equivalent to
158      * calling getInputStream(longOutput, "").  You must first connect to a
159      * finger server before calling this method, and you should disconnect
160      * after finishing reading the stream.
161      * <p>
162      * @param longOutput Set to true if long output is requested, false if not.
163      * @return The InputStream of the network connection of the finger query.
164      *         Can be read to obtain finger results.
165      * @exception IOException If an I/O error during the operation.
166      ***/
167     public InputStream getInputStream(boolean longOutput) throws IOException
168     {
169         return getInputStream(longOutput, "");
170     }
171 
172 }