| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.commons.net.nntp; |
| |
| import java.io.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.io.OutputStreamWriter; |
| import java.nio.charset.Charset; |
| import java.nio.charset.StandardCharsets; |
| |
| import org.apache.commons.net.MalformedServerReplyException; |
| import org.apache.commons.net.ProtocolCommandSupport; |
| import org.apache.commons.net.SocketClient; |
| import org.apache.commons.net.io.CRLFLineReader; |
| |
| /** |
| * The NNTP class is not meant to be used by itself and is provided |
| * only so that you may easily implement your own NNTP client if |
| * you so desire. If you have no need to perform your own implementation, |
| * you should use {@link org.apache.commons.net.nntp.NNTPClient}. |
| * The NNTP class is made public to provide access to various NNTP constants |
| * and to make it easier for adventurous programmers (or those with special |
| * needs) to interact with the NNTP protocol and implement their own clients. |
| * A set of methods with names corresponding to the NNTP command names are |
| * provided to facilitate this interaction. |
| * <p> |
| * You should keep in mind that the NNTP server may choose to prematurely |
| * close a connection if the client has been idle for longer than a |
| * given time period or if the server is being shutdown by the operator or |
| * some other reason. The NNTP class will detect a |
| * premature NNTP server connection closing when it receives a |
| * {@link org.apache.commons.net.nntp.NNTPReply#SERVICE_DISCONTINUED NNTPReply.SERVICE_DISCONTINUED } |
| * response to a command. |
| * When that occurs, the NNTP class method encountering that reply will throw |
| * an {@link org.apache.commons.net.nntp.NNTPConnectionClosedException} |
| * . |
| * <code>NNTPConectionClosedException</code> |
| * is a subclass of <code> IOException </code> and therefore need not be |
| * caught separately, but if you are going to catch it separately, its |
| * catch block must appear before the more general <code> IOException </code> |
| * catch block. When you encounter an |
| * {@link org.apache.commons.net.nntp.NNTPConnectionClosedException} |
| * , you must disconnect the connection with |
| * {@link #disconnect disconnect() } to properly clean up the |
| * system resources used by NNTP. Before disconnecting, you may check the |
| * last reply code and text with |
| * {@link #getReplyCode getReplyCode } and |
| * {@link #getReplyString getReplyString }. |
| * <p> |
| * Rather than list it separately for each method, we mention here that |
| * every method communicating with the server and throwing an IOException |
| * can also throw a |
| * {@link org.apache.commons.net.MalformedServerReplyException} |
| * , which is a subclass |
| * of IOException. A MalformedServerReplyException will be thrown when |
| * the reply received from the server deviates enough from the protocol |
| * specification that it cannot be interpreted in a useful manner despite |
| * attempts to be as lenient as possible. |
| * |
| * @see NNTPClient |
| * @see NNTPConnectionClosedException |
| * @see org.apache.commons.net.MalformedServerReplyException |
| */ |
| |
| public class NNTP extends SocketClient |
| { |
| /** The default NNTP port. Its value is 119 according to RFC 977. */ |
| public static final int DEFAULT_PORT = 119; |
| |
| // We have to ensure that the protocol communication is in ASCII |
| // but we use ISO-8859-1 just in case 8-bit characters cross |
| // the wire. |
| private static final Charset DEFAULT_ENCODING = StandardCharsets.ISO_8859_1; |
| |
| boolean _isAllowedToPost; |
| private int replyCode; |
| private String replyString; |
| |
| /** |
| * Wraps {@link SocketClient#_input_} |
| * to communicate with server. Initialized by {@link #_connectAction_}. |
| * All server reads should be done through this variable. |
| */ |
| protected BufferedReader _reader_; |
| |
| /** |
| * Wraps {@link SocketClient#_output_} |
| * to communicate with server. Initialized by {@link #_connectAction_}. |
| * All server reads should be done through this variable. |
| */ |
| protected BufferedWriter _writer_; |
| |
| /** |
| * A ProtocolCommandSupport object used to manage the registering of |
| * ProtocolCommandListeners and te firing of ProtocolCommandEvents. |
| */ |
| protected ProtocolCommandSupport _commandSupport_; |
| |
| /** |
| * The default NNTP constructor. Sets the default port to |
| * <code>DEFAULT_PORT</code> and initializes internal data structures |
| * for saving NNTP reply information. |
| */ |
| public NNTP() |
| { |
| setDefaultPort(DEFAULT_PORT); |
| replyString = null; |
| _reader_ = null; |
| _writer_ = null; |
| _isAllowedToPost = false; |
| _commandSupport_ = new ProtocolCommandSupport(this); |
| } |
| |
| /** |
| * Initiates control connections and gets initial reply, determining |
| * if the client is allowed to post to the server. Initializes |
| * {@link #_reader_} and {@link #_writer_} to wrap |
| * {@link SocketClient#_input_} and {@link SocketClient#_output_}. |
| */ |
| @Override |
| protected void _connectAction_() throws IOException |
| { |
| super._connectAction_(); |
| _reader_ = |
| new CRLFLineReader(new InputStreamReader(_input_, |
| DEFAULT_ENCODING)); |
| _writer_ = |
| new BufferedWriter(new OutputStreamWriter(_output_, |
| DEFAULT_ENCODING)); |
| getReply(); |
| |
| _isAllowedToPost = replyCode == NNTPReply.SERVER_READY_POSTING_ALLOWED; |
| } |
| |
| /** |
| * A convenience method to send the NNTP ARTICLE command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int article() throws IOException |
| { |
| return sendCommand(NNTPCommand.ARTICLE); |
| } |
| |
| |
| /** |
| * @param a article number |
| * @return number |
| * @throws IOException on error |
| * @deprecated - for API compatibility only - DO NOT USE |
| */ |
| @Deprecated |
| public int article(final int a) throws IOException |
| { |
| return article((long) a); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP ARTICLE command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param articleNumber The number of the article to request from the |
| * currently selected newsgroup. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int article(final long articleNumber) throws IOException |
| { |
| return sendCommand(NNTPCommand.ARTICLE, Long.toString(articleNumber)); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP ARTICLE command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param messageId The message identifier of the requested article, |
| * including the encapsulating < and > characters. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int article(final String messageId) throws IOException |
| { |
| return sendCommand(NNTPCommand.ARTICLE, messageId); |
| } |
| |
| |
| /** |
| * A convenience method to send the AUTHINFO PASS command to the server, |
| * receive the reply, and return the reply code. If this step is |
| * required, it should immediately follow the AUTHINFO USER command |
| * (See RFC 2980) |
| * <p> |
| * @param password a valid password. |
| * @return The reply code received from the server. The server should |
| * return a 281 or 502 for this command. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int authinfoPass(final String password) throws IOException { |
| final String passParameter = "PASS " + password; |
| return sendCommand(NNTPCommand.AUTHINFO, passParameter); |
| } |
| |
| |
| /** |
| * A convenience method to send the AUTHINFO USER command to the server, |
| * receive the reply, and return the reply code. (See RFC 2980) |
| * <p> |
| * @param username A valid username. |
| * @return The reply code received from the server. The server should |
| * return a 381 or 281 for this command. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int authinfoUser(final String username) throws IOException { |
| final String userParameter = "USER " + username; |
| return sendCommand(NNTPCommand.AUTHINFO, userParameter); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP BODY command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int body() throws IOException |
| { |
| return sendCommand(NNTPCommand.BODY); |
| } |
| |
| /** |
| * @param a article number |
| * @return number |
| * @throws IOException on error |
| * @deprecated - for API compatibility only - DO NOT USE |
| */ |
| @Deprecated |
| public int body(final int a) throws IOException |
| { |
| return body((long) a); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP BODY command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param articleNumber The number of the article to request from the |
| * currently selected newsgroup. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int body(final long articleNumber) throws IOException |
| { |
| return sendCommand(NNTPCommand.BODY, Long.toString(articleNumber)); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP BODY command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param messageId The message identifier of the requested article, |
| * including the encapsulating < and > characters. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int body(final String messageId) throws IOException |
| { |
| return sendCommand(NNTPCommand.BODY, messageId); |
| } |
| |
| /** |
| * Closes the connection to the NNTP server and sets to null |
| * some internal data so that the memory may be reclaimed by the |
| * garbage collector. The reply text and code information from the |
| * last command is voided so that the memory it used may be reclaimed. |
| * <p> |
| * @throws IOException If an error occurs while disconnecting. |
| */ |
| @Override |
| public void disconnect() throws IOException |
| { |
| super.disconnect(); |
| _reader_ = null; |
| _writer_ = null; |
| replyString = null; |
| _isAllowedToPost = false; |
| } |
| |
| /** |
| * Provide command support to super-class |
| */ |
| @Override |
| protected ProtocolCommandSupport getCommandSupport() { |
| return _commandSupport_; |
| } |
| |
| |
| |
| /** |
| * Fetches a reply from the NNTP server and returns the integer reply |
| * code. After calling this method, the actual reply text can be accessed |
| * from {@link #getReplyString getReplyString }. Only use this |
| * method if you are implementing your own NNTP client or if you need to |
| * fetch a secondary response from the NNTP server. |
| * <p> |
| * @return The integer value of the reply code of the fetched NNTP reply. |
| * in response to the command. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while |
| * receiving the server reply. |
| */ |
| public int getReply() throws IOException |
| { |
| replyString = _reader_.readLine(); |
| |
| if (replyString == null) { |
| throw new NNTPConnectionClosedException( |
| "Connection closed without indication."); |
| } |
| |
| // In case we run into an anomaly we don't want fatal index exceptions |
| // to be thrown. |
| if (replyString.length() < 3) { |
| throw new MalformedServerReplyException( |
| "Truncated server reply: " + replyString); |
| } |
| |
| try |
| { |
| replyCode = Integer.parseInt(replyString.substring(0, 3)); |
| } |
| catch (final NumberFormatException e) |
| { |
| throw new MalformedServerReplyException( |
| "Could not parse response code.\nServer Reply: " + replyString); |
| } |
| |
| fireReplyReceived(replyCode, replyString + SocketClient.NETASCII_EOL); |
| |
| if (replyCode == NNTPReply.SERVICE_DISCONTINUED) { |
| throw new NNTPConnectionClosedException( |
| "NNTP response 400 received. Server closed connection."); |
| } |
| return replyCode; |
| } |
| |
| /** |
| * Returns the integer value of the reply code of the last NNTP reply. |
| * You will usually only use this method after you connect to the |
| * NNTP server to check that the connection was successful since |
| * <code> connect </code> is of type void. |
| * <p> |
| * @return The integer value of the reply code of the last NNTP reply. |
| */ |
| public int getReplyCode() |
| { |
| return replyCode; |
| } |
| |
| /** |
| * Returns the entire text of the last NNTP server response exactly |
| * as it was received, not including the end of line marker. |
| * <p> |
| * @return The entire text from the last NNTP response as a String. |
| */ |
| public String getReplyString() |
| { |
| return replyString; |
| } |
| |
| |
| |
| /** |
| * A convenience method to send the NNTP GROUP command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @param newsgroup The name of the newsgroup to select. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int group(final String newsgroup) throws IOException |
| { |
| return sendCommand(NNTPCommand.GROUP, newsgroup); |
| } |
| |
| /** |
| * A convenience method to send the NNTP HEAD command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int head() throws IOException |
| { |
| return sendCommand(NNTPCommand.HEAD); |
| } |
| |
| /** |
| * @param a article number |
| * @return number |
| * @throws IOException on error |
| * @deprecated - for API compatibility only - DO NOT USE |
| */ |
| @Deprecated |
| public int head(final int a) throws IOException |
| { |
| return head((long) a); |
| } |
| |
| |
| |
| /** |
| * A convenience method to send the NNTP HEAD command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param articleNumber The number of the article to request from the |
| * currently selected newsgroup. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int head(final long articleNumber) throws IOException |
| { |
| return sendCommand(NNTPCommand.HEAD, Long.toString(articleNumber)); |
| } |
| |
| /** |
| * A convenience method to send the NNTP HEAD command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param messageId The message identifier of the requested article, |
| * including the encapsulating < and > characters. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int head(final String messageId) throws IOException |
| { |
| return sendCommand(NNTPCommand.HEAD, messageId); |
| } |
| |
| /** |
| * A convenience method to send the NNTP HELP command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int help() throws IOException |
| { |
| return sendCommand(NNTPCommand.HELP); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP IHAVE command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @param messageId The article identifier, |
| * including the encapsulating < and > characters. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int ihave(final String messageId) throws IOException |
| { |
| return sendCommand(NNTPCommand.IHAVE, messageId); |
| } |
| |
| |
| /** |
| * Indicates whether or not the client is allowed to post articles to |
| * the server it is currently connected to. |
| * <p> |
| * @return True if the client can post articles to the server, false |
| * otherwise. |
| */ |
| public boolean isAllowedToPost() |
| { |
| return _isAllowedToPost; |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP LAST command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int last() throws IOException |
| { |
| return sendCommand(NNTPCommand.LAST); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP LIST command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int list() throws IOException |
| { |
| return sendCommand(NNTPCommand.LIST); |
| } |
| |
| |
| |
| /** |
| * A convenience wrapper for the extended LIST command that takes |
| * an argument, allowing us to selectively list multiple groups. |
| * <p> |
| * @param wildmat A wildmat (pseudo-regex) pattern. See RFC 2980 for |
| * details. |
| * @return the reply code received from the server. |
| * @throws IOException if the command fails |
| */ |
| public int listActive(final String wildmat) throws IOException { |
| final StringBuilder command = new StringBuilder("ACTIVE "); |
| command.append(wildmat); |
| return sendCommand(NNTPCommand.LIST, command.toString()); |
| } |
| |
| |
| |
| /** |
| * A convenience method to send the "NEWGROUPS" command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @param date The date after which to check for new groups. |
| * Date format is YYMMDD |
| * @param time The time after which to check for new groups. |
| * Time format is HHMMSS using a 24-hour clock. |
| * @param GMT True if the time is in GMT, false if local server time. |
| * @param distributions Comma-separated distribution list to check for |
| * new groups. Set to null if no distributions. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int newgroups(final String date, final String time, final boolean GMT, |
| final String distributions) throws IOException |
| { |
| final StringBuilder buffer = new StringBuilder(); |
| |
| buffer.append(date); |
| buffer.append(' '); |
| buffer.append(time); |
| |
| if (GMT) |
| { |
| buffer.append(' '); |
| buffer.append("GMT"); |
| } |
| |
| if (distributions != null) |
| { |
| buffer.append(" <"); |
| buffer.append(distributions); |
| buffer.append('>'); |
| } |
| |
| return sendCommand(NNTPCommand.NEWGROUPS, buffer.toString()); |
| } |
| |
| |
| /** |
| * A convenience method to send the "NEWNEWS" command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @param newsgroups A comma-separated list of newsgroups to check for new |
| * news. |
| * @param date The date after which to check for new news. |
| * Date format is YYMMDD |
| * @param time The time after which to check for new news. |
| * Time format is HHMMSS using a 24-hour clock. |
| * @param GMT True if the time is in GMT, false if local server time. |
| * @param distributions Comma-separated distribution list to check for |
| * new news. Set to null if no distributions. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int newnews(final String newsgroups, final String date, final String time, final boolean GMT, |
| final String distributions) throws IOException |
| { |
| final StringBuilder buffer = new StringBuilder(); |
| |
| buffer.append(newsgroups); |
| buffer.append(' '); |
| buffer.append(date); |
| buffer.append(' '); |
| buffer.append(time); |
| |
| if (GMT) |
| { |
| buffer.append(' '); |
| buffer.append("GMT"); |
| } |
| |
| if (distributions != null) |
| { |
| buffer.append(" <"); |
| buffer.append(distributions); |
| buffer.append('>'); |
| } |
| |
| return sendCommand(NNTPCommand.NEWNEWS, buffer.toString()); |
| } |
| |
| |
| /** |
| * A convenience method to send the NNTP NEXT command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int next() throws IOException |
| { |
| return sendCommand(NNTPCommand.NEXT); |
| } |
| |
| |
| |
| /** |
| * A convenience method to send the NNTP POST command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int post() throws IOException |
| { |
| return sendCommand(NNTPCommand.POST); |
| } |
| |
| |
| |
| /** |
| * A convenience method to send the NNTP QUIT command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int quit() throws IOException |
| { |
| return sendCommand(NNTPCommand.QUIT); |
| } |
| |
| /** |
| * Sends an NNTP command with no arguments to the server, waits for a |
| * reply and returns the numerical response code. After invocation, for |
| * more detailed information, the actual reply text can be accessed by |
| * calling {@link #getReplyString getReplyString }. |
| * <p> |
| * @param command The NNTPCommand constant corresponding to the NNTP command |
| * to send. |
| * @return The integer value of the NNTP reply code returned by the server |
| * in response to the command. |
| * in response to the command. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int sendCommand(final int command) throws IOException |
| { |
| return sendCommand(command, null); |
| } |
| |
| /** |
| * Sends an NNTP command to the server, waits for a reply and returns the |
| * numerical response code. After invocation, for more detailed |
| * information, the actual reply text can be accessed by calling |
| * {@link #getReplyString getReplyString }. |
| * <p> |
| * @param command The NNTPCommand constant corresponding to the NNTP command |
| * to send. |
| * @param args The arguments to the NNTP command. If this parameter is |
| * set to null, then the command is sent with no argument. |
| * @return The integer value of the NNTP reply code returned by the server |
| * in response to the command. |
| * in response to the command. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int sendCommand(final int command, final String args) throws IOException |
| { |
| return sendCommand(NNTPCommand.getCommand(command), args); |
| } |
| |
| /** |
| * Sends an NNTP command with no arguments to the server, waits for a |
| * reply and returns the numerical response code. After invocation, for |
| * more detailed information, the actual reply text can be accessed by |
| * calling {@link #getReplyString getReplyString }. |
| * <p> |
| * @param command The text representation of the NNTP command to send. |
| * @return The integer value of the NNTP reply code returned by the server |
| * in response to the command. |
| * in response to the command. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int sendCommand(final String command) throws IOException |
| { |
| return sendCommand(command, null); |
| } |
| |
| /** |
| * Sends an NNTP command to the server, waits for a reply and returns the |
| * numerical response code. After invocation, for more detailed |
| * information, the actual reply text can be accessed by calling |
| * {@link #getReplyString getReplyString }. |
| * <p> |
| * @param command The text representation of the NNTP command to send. |
| * @param args The arguments to the NNTP command. If this parameter is |
| * set to null, then the command is sent with no argument. |
| * @return The integer value of the NNTP reply code returned by the server |
| * in response to the command. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int sendCommand(final String command, final String args) throws IOException |
| { |
| final StringBuilder __commandBuffer = new StringBuilder(); |
| __commandBuffer.append(command); |
| |
| if (args != null) |
| { |
| __commandBuffer.append(' '); |
| __commandBuffer.append(args); |
| } |
| __commandBuffer.append(SocketClient.NETASCII_EOL); |
| |
| final String message; |
| _writer_.write(message = __commandBuffer.toString()); |
| _writer_.flush(); |
| |
| fireCommandSent(command, message); |
| |
| return getReply(); |
| } |
| |
| /** |
| * A convenience method to send the NNTP STAT command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int stat() throws IOException |
| { |
| return sendCommand(NNTPCommand.STAT); |
| } |
| |
| // DEPRECATED METHODS - for API compatibility only - DO NOT USE |
| |
| /** |
| * @param a article number |
| * @return number |
| * @throws IOException on error |
| * @deprecated - for API compatibility only - DO NOT USE |
| */ |
| @Deprecated |
| public int stat(final int a) throws IOException |
| { |
| return stat((long) a); |
| } |
| |
| /** |
| * A convenience method to send the NNTP STAT command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param articleNumber The number of the article to request from the |
| * currently selected newsgroup. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int stat(final long articleNumber) throws IOException |
| { |
| return sendCommand(NNTPCommand.STAT, Long.toString(articleNumber)); |
| } |
| |
| /** |
| * A convenience method to send the NNTP STAT command to the server, |
| * receive the initial reply, and return the reply code. |
| * <p> |
| * @param messageId The message identifier of the requested article, |
| * including the encapsulating < and > characters. |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int stat(final String messageId) throws IOException |
| { |
| return sendCommand(NNTPCommand.STAT, messageId); |
| } |
| |
| /** |
| * A convenience method to send the NNTP XHDR command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @param header a String naming a header line (e.g., "subject"). See |
| * RFC-1036 for a list of valid header lines. |
| * @param selectedArticles a String representation of the range of |
| * article headers required. This may be an article number, or a |
| * range of article numbers in the form "XXXX-YYYY", where XXXX |
| * and YYYY are valid article numbers in the current group. It |
| * also may be of the form "XXX-", meaning "return XXX and all |
| * following articles" In this revision, the last format is not |
| * possible (yet). |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int xhdr(final String header, final String selectedArticles) throws IOException { |
| final StringBuilder command = new StringBuilder(header); |
| command.append(" "); |
| command.append(selectedArticles); |
| return sendCommand(NNTPCommand.XHDR, command.toString()); |
| } |
| |
| /** |
| * A convenience method to send the NNTP XOVER command to the server, |
| * receive the reply, and return the reply code. |
| * <p> |
| * @param selectedArticles a String representation of the range of |
| * article headers required. This may be an article number, or a |
| * range of article numbers in the form "XXXX-YYYY", where XXXX |
| * and YYYY are valid article numbers in the current group. It |
| * also may be of the form "XXX-", meaning "return XXX and all |
| * following articles" In this revision, the last format is not |
| * possible (yet). |
| * @return The reply code received from the server. |
| * @throws NNTPConnectionClosedException |
| * If the NNTP server prematurely closes the connection as a result |
| * of the client being idle or some other reason causing the server |
| * to send NNTP reply code 400. This exception may be caught either |
| * as an IOException or independently as itself. |
| * @throws IOException If an I/O error occurs while either sending the |
| * command or receiving the server reply. |
| */ |
| public int xover(final String selectedArticles) throws IOException { |
| return sendCommand(NNTPCommand.XOVER, selectedArticles); |
| } |
| } |
