This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-net.git
The following commit(s) were added to refs/heads/master by this push:
new 9154da3f Remove extra whitespace in Javadoc @link tags
9154da3f is described below
commit 9154da3fe8ed6b0797716b03233e12614263122e
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Wed Mar 5 09:13:06 2025 -0500
Remove extra whitespace in Javadoc @link tags
---
.../org/apache/commons/net/DatagramSocketClient.java | 4 ++--
src/main/java/org/apache/commons/net/SocketClient.java | 8 ++++----
.../apache/commons/net/chargen/CharGenTCPClient.java | 6 +++---
.../apache/commons/net/chargen/CharGenUDPClient.java | 4 ++--
.../apache/commons/net/daytime/DaytimeTCPClient.java | 8 ++++----
.../apache/commons/net/daytime/DaytimeUDPClient.java | 6 +++---
.../apache/commons/net/discard/DiscardTCPClient.java | 6 +++---
.../apache/commons/net/discard/DiscardUDPClient.java | 2 +-
.../org/apache/commons/net/echo/EchoTCPClient.java | 4 ++--
.../org/apache/commons/net/echo/EchoUDPClient.java | 2 +-
src/main/java/org/apache/commons/net/ftp/FTP.java | 18 +++++++++---------
.../java/org/apache/commons/net/ftp/FTPClient.java | 18 +++++++++---------
.../java/org/apache/commons/net/ftp/FTPCommand.java | 2 +-
.../commons/net/ftp/FTPConnectionClosedException.java | 2 +-
.../java/org/apache/commons/net/imap/IMAPClient.java | 2 +-
src/main/java/org/apache/commons/net/io/Util.java | 2 +-
src/main/java/org/apache/commons/net/nntp/NNTP.java | 16 ++++++++--------
.../java/org/apache/commons/net/nntp/NNTPClient.java | 8 ++++----
.../net/nntp/NNTPConnectionClosedException.java | 2 +-
.../apache/commons/net/nntp/NewGroupsOrNewsQuery.java | 2 +-
.../org/apache/commons/net/nntp/NewsgroupInfo.java | 4 ++--
src/main/java/org/apache/commons/net/pop3/POP3.java | 4 ++--
.../java/org/apache/commons/net/pop3/POP3Client.java | 16 ++++++++--------
src/main/java/org/apache/commons/net/smtp/SMTP.java | 14 +++++++-------
.../java/org/apache/commons/net/smtp/SMTPClient.java | 14 +++++++-------
.../java/org/apache/commons/net/smtp/SMTPCommand.java | 2 +-
.../net/smtp/SMTPConnectionClosedException.java | 2 +-
.../org/apache/commons/net/telnet/TelnetClient.java | 2 +-
.../org/apache/commons/net/time/TimeTCPClient.java | 12 ++++++------
.../org/apache/commons/net/time/TimeUDPClient.java | 6 +++---
30 files changed, 99 insertions(+), 99 deletions(-)
diff --git a/src/main/java/org/apache/commons/net/DatagramSocketClient.java
b/src/main/java/org/apache/commons/net/DatagramSocketClient.java
index 449e799d..520045a8 100644
--- a/src/main/java/org/apache/commons/net/DatagramSocketClient.java
+++ b/src/main/java/org/apache/commons/net/DatagramSocketClient.java
@@ -29,10 +29,10 @@ import org.apache.commons.io.IOUtils;
/**
* The DatagramSocketClient provides the basic operations that are required of
client objects accessing datagram sockets. It is meant to be subclassed to avoid
* having to rewrite the same code over and over again to open a socket, close
a socket, set timeouts, etc. Of special note is the
- * {@link #setDatagramSocketFactory setDatagramSocketFactory } method, which
allows you to control the type of DatagramSocket the DatagramSocketClient
creates
+ * {@link #setDatagramSocketFactory setDatagramSocketFactory)} method, which
allows you to control the type of DatagramSocket the DatagramSocketClient
creates
* for network communications. This is especially useful for adding things
like proxy support as well as better support for applets. For example, you could
* create a {@link org.apache.commons.net.DatagramSocketFactory} that requests
browser security capabilities before creating a socket. All classes derived from
- * DatagramSocketClient should use the {@link #_socketFactory_ _socketFactory_
} member variable to create DatagramSocket instances rather than instantiating
+ * DatagramSocketClient should use the {@link #_socketFactory_
_socketFactory_} member variable to create DatagramSocket instances rather than
instantiating
* them by directly invoking a constructor. By honoring this contract you
guarantee that a user will always be able to provide his own Socket
implementations by
* substituting his own SocketFactory.
*
diff --git a/src/main/java/org/apache/commons/net/SocketClient.java
b/src/main/java/org/apache/commons/net/SocketClient.java
index ba872ff8..1d60d929 100644
--- a/src/main/java/org/apache/commons/net/SocketClient.java
+++ b/src/main/java/org/apache/commons/net/SocketClient.java
@@ -35,10 +35,10 @@ import org.apache.commons.io.IOUtils;
/**
* The SocketClient provides the basic operations that are required of client
objects accessing sockets. It is meant to be subclassed to avoid having to
rewrite
- * the same code over and over again to open a socket, close a socket, set
timeouts, etc. Of special note is the {@link #setSocketFactory setSocketFactory
}
+ * the same code over and over again to open a socket, close a socket, set
timeouts, etc. Of special note is the {@link #setSocketFactory setSocketFactory}
* method, which allows you to control the type of Socket the SocketClient
creates for initiating network connections. This is especially useful for
adding SSL
* or proxy support as well as better support for applets. For example, you
could create a {@link javax.net.SocketFactory} that requests browser security
- * capabilities before creating a socket. All classes derived from
SocketClient should use the {@link #_socketFactory_ _socketFactory_ } member
variable to
+ * capabilities before creating a socket. All classes derived from
SocketClient should use the {@link #_socketFactory_ _socketFactory_} member
variable to
* create Socket and ServerSocket instances rather than instantiating them by
directly invoking a constructor. By honoring this contract you guarantee that a
* user will always be able to provide his own Socket implementations by
substituting his own SocketFactory.
*
@@ -404,7 +404,7 @@ public abstract class SocketClient {
}
/**
- * Gets the current value of the default port (stored in {@link
#_defaultPort_ _defaultPort_ }).
+ * Gets the current value of the default port (stored in {@link
#_defaultPort_ _defaultPort_}).
*
* @return The current value of the default port.
*/
@@ -646,7 +646,7 @@ public abstract class SocketClient {
}
/**
- * Sets the default port the SocketClient should connect to when a port is
not specified. The {@link #_defaultPort_ _defaultPort_ } variable stores this
+ * Sets the default port the SocketClient should connect to when a port is
not specified. The {@link #_defaultPort_ _defaultPort_} variable stores this
* value. If never set, the default port is equal to zero.
*
* @param port The default port to set.
diff --git a/src/main/java/org/apache/commons/net/chargen/CharGenTCPClient.java
b/src/main/java/org/apache/commons/net/chargen/CharGenTCPClient.java
index 5d8a12f6..c6fd8b54 100644
--- a/src/main/java/org/apache/commons/net/chargen/CharGenTCPClient.java
+++ b/src/main/java/org/apache/commons/net/chargen/CharGenTCPClient.java
@@ -27,9 +27,9 @@ import org.apache.commons.net.SocketClient;
* stream. The chargen protocol actually sends data until the receiving end
closes the connection. All the others send only a fixed amount of data and then
* close the connection.
* <p>
- * To use the CharGenTCPClient class, just establish a connection with {@link
org.apache.commons.net.SocketClient#connect connect } and call
+ * To use the CharGenTCPClient class, just establish a connection with {@link
org.apache.commons.net.SocketClient#connect connect} and call
* {@link #getInputStream getInputStream()} to access the data. Don't close
the input stream when you're done with it. Rather, call
- * {@link org.apache.commons.net.SocketClient#disconnect disconnect } to clean
up properly.
+ * {@link org.apache.commons.net.SocketClient#disconnect disconnect} to clean
up properly.
* </p>
*
* @see CharGenUDPClient
@@ -60,7 +60,7 @@ public final class CharGenTCPClient extends SocketClient {
/**
* Gets an InputStream from which the server generated data can be read.
You should NOT close the InputStream when you're finished reading from it.
- * Rather, you should call {@link
org.apache.commons.net.SocketClient#disconnect disconnect } to clean up
properly.
+ * Rather, you should call {@link
org.apache.commons.net.SocketClient#disconnect disconnect} to clean up properly.
*
* @return An InputStream from which the server generated data can be read.
*/
diff --git a/src/main/java/org/apache/commons/net/chargen/CharGenUDPClient.java
b/src/main/java/org/apache/commons/net/chargen/CharGenUDPClient.java
index 69d8c2fc..66c2fcd6 100644
--- a/src/main/java/org/apache/commons/net/chargen/CharGenUDPClient.java
+++ b/src/main/java/org/apache/commons/net/chargen/CharGenUDPClient.java
@@ -30,8 +30,8 @@ import org.apache.commons.net.util.NetConstants;
* contained in one or more reply datagrams. The chargen and quote of the day
protocols only send one reply datagram containing 512 bytes or fewer. The
* other protocols may reply with more than one datagram, in which case you
must wait for a timeout to determine that all reply datagrams have been sent.
* <p>
- * To use the CharGenUDPClient class, just open a local UDP port with {@link
org.apache.commons.net.DatagramSocketClient#open open } and call {@link #send
send
- * } to send the datagram that will initiate the data reply. For chargen or
quote of the day, just call {@link #receive receive }, and you're done. For
netstat
+ * To use the CharGenUDPClient class, just open a local UDP port with {@link
org.apache.commons.net.DatagramSocketClient#open open} and call {@link #send
send
+ * } to send the datagram that will initiate the data reply. For chargen or
quote of the day, just call {@link #receive receive}, and you're done. For
netstat
* and systat, call receive in a while loop, and catch a SocketException and
InterruptedIOException to detect a timeout (don't forget to set the timeout
* duration beforehand). Don't forget to call {@link
org.apache.commons.net.DatagramSocketClient#close close()} to clean up properly.
* </p>
diff --git a/src/main/java/org/apache/commons/net/daytime/DaytimeTCPClient.java
b/src/main/java/org/apache/commons/net/daytime/DaytimeTCPClient.java
index b0764450..a927297c 100644
--- a/src/main/java/org/apache/commons/net/daytime/DaytimeTCPClient.java
+++ b/src/main/java/org/apache/commons/net/daytime/DaytimeTCPClient.java
@@ -24,8 +24,8 @@ import org.apache.commons.net.SocketClient;
/**
* The DaytimeTCPClient class is a TCP implementation of a client for the
Daytime protocol described in RFC 867. To use the class, merely establish a
connection
- * with {@link org.apache.commons.net.SocketClient#connect connect } and call
{@link #getTime getTime()} to retrieve the daytime string, then call
- * {@link org.apache.commons.net.SocketClient#disconnect disconnect } to close
the connection properly.
+ * with {@link org.apache.commons.net.SocketClient#connect connect} and call
{@link #getTime getTime()} to retrieve the daytime string, then call
+ * {@link org.apache.commons.net.SocketClient#disconnect disconnect} to close
the connection properly.
*
* @see DaytimeUDPClient
*/
@@ -45,8 +45,8 @@ public final class DaytimeTCPClient extends SocketClient {
/**
* Gets the time string from the server and returns it. The server will
have closed the connection at this point, so you should call
- * {@link org.apache.commons.net.SocketClient#disconnect disconnect }
after calling this method. To retrieve another time, you must initiate another
- * connection with {@link org.apache.commons.net.SocketClient#connect
connect } before calling {@code getTime()} again.
+ * {@link org.apache.commons.net.SocketClient#disconnect disconnect} after
calling this method. To retrieve another time, you must initiate another
+ * connection with {@link org.apache.commons.net.SocketClient#connect
connect} before calling {@code getTime()} again.
*
* @return The time string retrieved from the server.
* @throws IOException If an error occurs while fetching the time string.
diff --git a/src/main/java/org/apache/commons/net/daytime/DaytimeUDPClient.java
b/src/main/java/org/apache/commons/net/daytime/DaytimeUDPClient.java
index b3682b54..ae562b00 100644
--- a/src/main/java/org/apache/commons/net/daytime/DaytimeUDPClient.java
+++ b/src/main/java/org/apache/commons/net/daytime/DaytimeUDPClient.java
@@ -25,9 +25,9 @@ import org.apache.commons.net.DatagramSocketClient;
/**
* The DaytimeUDPClient class is a UDP implementation of a client for the
Daytime protocol described in RFC 867. To use the class, merely open a local
datagram
- * socket with {@link org.apache.commons.net.DatagramSocketClient#open open }
and call {@link #getTime getTime } to retrieve the daytime string, then call
- * {@link org.apache.commons.net.DatagramSocketClient#close close } to close
the connection properly. Unlike
- * {@link org.apache.commons.net.daytime.DaytimeTCPClient}, successive calls
to {@link #getTime getTime } are permitted without re-establishing a connection.
+ * socket with {@link org.apache.commons.net.DatagramSocketClient#open open}
and call {@link #getTime getTime} to retrieve the daytime string, then call
+ * {@link org.apache.commons.net.DatagramSocketClient#close close} to close
the connection properly. Unlike
+ * {@link org.apache.commons.net.daytime.DaytimeTCPClient}, successive calls
to {@link #getTime getTime} are permitted without re-establishing a connection.
* That is because UDP is a connectionless protocol and the Daytime protocol
is stateless.
*
* @see DaytimeTCPClient
diff --git a/src/main/java/org/apache/commons/net/discard/DiscardTCPClient.java
b/src/main/java/org/apache/commons/net/discard/DiscardTCPClient.java
index 6eed81f2..2221c88f 100644
--- a/src/main/java/org/apache/commons/net/discard/DiscardTCPClient.java
+++ b/src/main/java/org/apache/commons/net/discard/DiscardTCPClient.java
@@ -23,8 +23,8 @@ import org.apache.commons.net.SocketClient;
/**
* The DiscardTCPClient class is a TCP implementation of a client for the
Discard protocol described in RFC 863. To use the class, merely establish a
connection
- * with {@link org.apache.commons.net.SocketClient#connect connect } and call
{@link #getOutputStream getOutputStream()} to retrieve the discard output
stream.
- * Don't close the output stream when you're done writing to it. Rather, call
{@link org.apache.commons.net.SocketClient#disconnect disconnect } to clean up
+ * with {@link org.apache.commons.net.SocketClient#connect connect} and call
{@link #getOutputStream getOutputStream()} to retrieve the discard output
stream.
+ * Don't close the output stream when you're done writing to it. Rather, call
{@link org.apache.commons.net.SocketClient#disconnect disconnect} to clean up
* properly.
*
* @see DiscardUDPClient
@@ -43,7 +43,7 @@ public class DiscardTCPClient extends SocketClient {
/**
* Gets an OutputStream through which you may write data to the server.
You should NOT close the OutputStream when you're finished reading from it.
- * Rather, you should call {@link
org.apache.commons.net.SocketClient#disconnect disconnect } to clean up
properly.
+ * Rather, you should call {@link
org.apache.commons.net.SocketClient#disconnect disconnect} to clean up properly.
*
* @return An OutputStream through which you can write data to the server.
*/
diff --git a/src/main/java/org/apache/commons/net/discard/DiscardUDPClient.java
b/src/main/java/org/apache/commons/net/discard/DiscardUDPClient.java
index de06dc22..fb4aaf55 100644
--- a/src/main/java/org/apache/commons/net/discard/DiscardUDPClient.java
+++ b/src/main/java/org/apache/commons/net/discard/DiscardUDPClient.java
@@ -26,7 +26,7 @@ import org.apache.commons.net.util.NetConstants;
/**
* The DiscardUDPClient class is a UDP implementation of a client for the
Discard protocol described in RFC 863. To use the class, just open a local UDP
port
- * with {@link org.apache.commons.net.DatagramSocketClient#open open } and
call {@link #send send } to send datagrams to the server After you're done
sending
+ * with {@link org.apache.commons.net.DatagramSocketClient#open open} and call
{@link #send send} to send datagrams to the server After you're done sending
* discard data, call {@link org.apache.commons.net.DatagramSocketClient#close
close()} to clean up properly.
*
* @see DiscardTCPClient
diff --git a/src/main/java/org/apache/commons/net/echo/EchoTCPClient.java
b/src/main/java/org/apache/commons/net/echo/EchoTCPClient.java
index 237f97b8..1d352730 100644
--- a/src/main/java/org/apache/commons/net/echo/EchoTCPClient.java
+++ b/src/main/java/org/apache/commons/net/echo/EchoTCPClient.java
@@ -23,9 +23,9 @@ import org.apache.commons.net.discard.DiscardTCPClient;
/**
* The EchoTCPClient class is a TCP implementation of a client for the Echo
protocol described in RFC 862. To use the class, merely establish a connection
with
- * {@link org.apache.commons.net.SocketClient#connect connect } and call
{@link DiscardTCPClient#getOutputStream getOutputStream()} to retrieve the echo
output
+ * {@link org.apache.commons.net.SocketClient#connect connect} and call {@link
DiscardTCPClient#getOutputStream getOutputStream()} to retrieve the echo output
* stream and {@link #getInputStream getInputStream()} to get the echo input
stream. Don't close either stream when you're done using them. Rather, call
- * {@link org.apache.commons.net.SocketClient#disconnect disconnect } to clean
up properly.
+ * {@link org.apache.commons.net.SocketClient#disconnect disconnect} to clean
up properly.
*
* @see EchoUDPClient
* @see DiscardTCPClient
diff --git a/src/main/java/org/apache/commons/net/echo/EchoUDPClient.java
b/src/main/java/org/apache/commons/net/echo/EchoUDPClient.java
index 1d45611d..9554bc37 100644
--- a/src/main/java/org/apache/commons/net/echo/EchoUDPClient.java
+++ b/src/main/java/org/apache/commons/net/echo/EchoUDPClient.java
@@ -26,7 +26,7 @@ import org.apache.commons.net.util.NetConstants;
/**
* The EchoUDPClient class is a UDP implementation of a client for the Echo
protocol described in RFC 862. To use the class, just open a local UDP port with
- * {@link org.apache.commons.net.DatagramSocketClient#open open } and call
{@link #send send } to send datagrams to the server, then call {@link #receive
+ * {@link org.apache.commons.net.DatagramSocketClient#open open} and call
{@link #send send} to send datagrams to the server, then call {@link #receive
* receive } to receive echoes. After you're done echoing data, call {@link
org.apache.commons.net.DatagramSocketClient#close close()} to clean up properly.
*
* @see EchoTCPClient
diff --git a/src/main/java/org/apache/commons/net/ftp/FTP.java
b/src/main/java/org/apache/commons/net/ftp/FTP.java
index c3e72b7d..077d9751 100644
--- a/src/main/java/org/apache/commons/net/ftp/FTP.java
+++ b/src/main/java/org/apache/commons/net/ftp/FTP.java
@@ -52,12 +52,12 @@ import org.apache.commons.net.util.NetConstants;
* <p>
* You should keep in mind that the FTP server may choose to prematurely close
a connection if the client has been idle for longer than a given time period
* (usually 900 seconds). The FTP class will detect a premature FTP server
connection closing when it receives a
- * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE
FTPReply.SERVICE_NOT_AVAILABLE } response to a command. When that occurs, the
FTP class
+ * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE
FTPReply.SERVICE_NOT_AVAILABLE} response to a command. When that occurs, the
FTP class
* method encountering that reply will throw an {@link
org.apache.commons.net.ftp.FTPConnectionClosedException}. {@code
FTPConectionClosedException} is a
* subclass of {@code IOException} 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} catch block. When you encounter
an {@link org.apache.commons.net.ftp.FTPConnectionClosedException} , you
* must disconnect the connection with {@link #disconnect disconnect()} to
properly clean up the system resources used by FTP. Before disconnecting, you
may
- * check the last reply code and text with {@link #getReplyCode getReplyCode
}, {@link #getReplyString getReplyString }, and {@link #getReplyStrings
+ * check the last reply code and text with {@link #getReplyCode getReplyCode},
{@link #getReplyString getReplyString}, and {@link #getReplyStrings
* getReplyStrings}. You may avoid server disconnections while the client is
idle by periodically sending NOOP commands to the server.
* </p>
* <p>
@@ -588,7 +588,7 @@ public class FTP extends SocketClient {
/**
* Gets a reply from the FTP server and returns the integer reply code.
After calling this method, the actual reply text can be accessed from either
- * calling {@link #getReplyString getReplyString } or {@link
#getReplyStrings getReplyStrings }. Only use this method if you are
implementing your own FTP
+ * calling {@link #getReplyString getReplyString} or {@link
#getReplyStrings getReplyStrings}. Only use this method if you are implementing
your own FTP
* client or if you need to fetch a secondary response from the FTP server.
*
* @return The integer value of the reply code of the fetched FTP reply.
@@ -1203,7 +1203,7 @@ public class FTP extends SocketClient {
/**
* Sends an FTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The FTPCmd enum corresponding to the FTP command to send.
* @return The integer value of the FTP reply code returned by the server
in response to the command.
@@ -1219,7 +1219,7 @@ public class FTP extends SocketClient {
/**
* Sends an FTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The FTPCmd enum corresponding to the FTP command to send.
* @param args The arguments to the FTP command. If this parameter is
set to null, then the command is sent with no argument.
@@ -1236,7 +1236,7 @@ public class FTP extends SocketClient {
/**
* Sends an FTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * information, the actual reply text can be accessed by calling {@link
#getReplyString getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The FTPCommand constant corresponding to the FTP command
to send.
* @return The integer value of the FTP reply code returned by the server
in response to the command.
@@ -1251,7 +1251,7 @@ public class FTP extends SocketClient {
/**
* Sends an FTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The FTPCommand constant corresponding to the FTP command
to send.
* @param args The arguments to the FTP command. If this parameter is
set to null, then the command is sent with no argument.
@@ -1269,7 +1269,7 @@ public class FTP extends SocketClient {
/**
* Sends an FTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * information, the actual reply text can be accessed by calling {@link
#getReplyString getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The text representation of the FTP command to send.
* @return The integer value of the FTP reply code returned by the server
in response to the command.
@@ -1284,7 +1284,7 @@ public class FTP extends SocketClient {
/**
* Sends an FTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The text representation of the FTP command to send.
* @param args The arguments to the FTP command. If this parameter is
set to null, then the command is sent with no argument.
diff --git a/src/main/java/org/apache/commons/net/ftp/FTPClient.java
b/src/main/java/org/apache/commons/net/ftp/FTPClient.java
index b0a766fd..08d37449 100644
--- a/src/main/java/org/apache/commons/net/ftp/FTPClient.java
+++ b/src/main/java/org/apache/commons/net/ftp/FTPClient.java
@@ -66,7 +66,7 @@ import org.apache.commons.net.util.NetConstants;
/**
* FTPClient encapsulates all the functionality necessary to store and
retrieve files from an FTP server. This class takes care of all low level
details of
* interacting with an FTP server and provides a convenient higher level
interface. As with all classes derived from
- * {@link org.apache.commons.net.SocketClient}, you must first connect to the
server with {@link org.apache.commons.net.SocketClient#connect connect } before
+ * {@link org.apache.commons.net.SocketClient}, you must first connect to the
server with {@link org.apache.commons.net.SocketClient#connect connect} before
* doing anything, and finally {@link
org.apache.commons.net.SocketClient#disconnect() disconnect} after you're
completely finished interacting with the server.
* Then you need to check the FTP reply code to see if the connection was
successful. For example:
*
@@ -114,7 +114,7 @@ import org.apache.commons.net.util.NetConstants;
* methods in FTPClient is such that they either return a boolean value or
some other value. The boolean methods return true on a successful completion
reply
* from the FTP server and false on a reply resulting in an error condition or
failure. The methods returning a value other than boolean return a value
* containing the higher level data produced by the FTP command, or null if a
reply resulted in an error condition or failure. If you want to access the exact
- * FTP reply code causing a success or failure, you must call {@link
org.apache.commons.net.ftp.FTP#getReplyCode getReplyCode } after a success or
failure.
+ * FTP reply code causing a success or failure, you must call {@link
org.apache.commons.net.ftp.FTP#getReplyCode getReplyCode} after a success or
failure.
* </p>
* <p>
* The default settings for FTPClient are for it to use {@link
FTP#ASCII_FILE_TYPE}, {@link FTP#NON_PRINT_TEXT_FORMAT}, {@link
FTP#STREAM_TRANSFER_MODE}, and
@@ -141,12 +141,12 @@ import org.apache.commons.net.util.NetConstants;
* <p>
* You should keep in mind that the FTP server may choose to prematurely close
a connection if the client has been idle for longer than a given time period
* (usually 900 seconds). The FTPClient class will detect a premature FTP
server connection closing when it receives a
- * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE
FTPReply.SERVICE_NOT_AVAILABLE } response to a command. When that occurs, the
FTP class
+ * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE
FTPReply.SERVICE_NOT_AVAILABLE} response to a command. When that occurs, the
FTP class
* method encountering that reply will throw an {@link
org.apache.commons.net.ftp.FTPConnectionClosedException}. {@link
FTPConnectionClosedException} is a
* subclass of {@code IOException} 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} catch block. When you encounter an
{@link org.apache.commons.net.ftp.FTPConnectionClosedException} , you must
disconnect
* the connection with {@link #disconnect disconnect()} to properly clean up
the system resources used by FTPClient. Before disconnecting, you may check the
- * last reply code and text with {@link
org.apache.commons.net.ftp.FTP#getReplyCode getReplyCode }, {@link
org.apache.commons.net.ftp.FTP#getReplyString
+ * last reply code and text with {@link
org.apache.commons.net.ftp.FTP#getReplyCode getReplyCode}, {@link
org.apache.commons.net.ftp.FTP#getReplyString
* getReplyString }, and {@link org.apache.commons.net.ftp.FTP#getReplyStrings
getReplyStrings}. You may avoid server disconnections while the client is idle
by
* periodically sending NOOP commands to the server.
* </p>
@@ -1132,7 +1132,7 @@ public class FTPClient extends FTP implements
Configurable {
* do this). You must close the OutputStream when you finish writing to
it. The OutputStream itself will take care of closing the parent data connection
* socket upon being closed.
* <p>
- * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand } and check its return value to
verify
+ * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand} and check its return value to
verify
* success.</strong> If this is not done, subsequent commands may behave
unexpectedly.
* </p>
*
@@ -2839,7 +2839,7 @@ public class FTPClient extends FTP implements
Configurable {
* separators in the file to the local representation. You must close the
InputStream when you finish reading from it. The InputStream itself will take
care
* of closing the parent data connection socket upon being closed.
* <p>
- * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand } and check its return value to
verify
+ * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand} and check its return value to
verify
* success.</strong> If this is not done, subsequent commands may behave
unexpectedly.
* <p>
* Note: if you have used {@link #setRestartOffset(long)}, the file data
will start from the selected offset.
@@ -3333,7 +3333,7 @@ public class FTPClient extends FTP implements
Configurable {
* do this). You must close the OutputStream when you finish writing to
it. The OutputStream itself will take care of closing the parent data connection
* socket upon being closed.
* <p>
- * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand } and check its return value to
verify
+ * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand} and check its return value to
verify
* success.</strong> If this is not done, subsequent commands may behave
unexpectedly.
* </p>
*
@@ -3396,7 +3396,7 @@ public class FTPClient extends FTP implements
Configurable {
* special OutputStream to do this). You must close the OutputStream when
you finish writing to it. The OutputStream itself will take care of closing the
* parent data connection socket upon being closed.
* <p>
- * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand } and check its return value to
verify
+ * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand} and check its return value to
verify
* success.</strong> If this is not done, subsequent commands may behave
unexpectedly.
* </p>
*
@@ -3417,7 +3417,7 @@ public class FTPClient extends FTP implements
Configurable {
* special OutputStream to do this). You must close the OutputStream when
you finish writing to it. The OutputStream itself will take care of closing the
* parent data connection socket upon being closed.
* <p>
- * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand } and check its return value to
verify
+ * <strong>To finalize the file transfer you must call {@link
#completePendingCommand completePendingCommand} and check its return value to
verify
* success.</strong> If this is not done, subsequent commands may behave
unexpectedly.
* </p>
*
diff --git a/src/main/java/org/apache/commons/net/ftp/FTPCommand.java
b/src/main/java/org/apache/commons/net/ftp/FTPCommand.java
index 53e4c5a6..8e4538e7 100644
--- a/src/main/java/org/apache/commons/net/ftp/FTPCommand.java
+++ b/src/main/java/org/apache/commons/net/ftp/FTPCommand.java
@@ -20,7 +20,7 @@ package org.apache.commons.net.ftp;
/**
* FTPCommand stores a set of constants for FTP command codes. To interpret
the meaning of the codes, familiarity with RFC 959 is assumed. The mnemonic
constant
* names are transcriptions from the code descriptions of RFC 959. For those
who think in terms of the actual FTP commands, a set of constants such as
- * {@link #USER USER } are provided where the constant name is the same as the
FTP command.
+ * {@link #USER USER} are provided where the constant name is the same as the
FTP command.
*
* @deprecated use {@link FTPCmd} instead
*/
diff --git
a/src/main/java/org/apache/commons/net/ftp/FTPConnectionClosedException.java
b/src/main/java/org/apache/commons/net/ftp/FTPConnectionClosedException.java
index 3161b9fb..1f4e8ad4 100644
--- a/src/main/java/org/apache/commons/net/ftp/FTPConnectionClosedException.java
+++ b/src/main/java/org/apache/commons/net/ftp/FTPConnectionClosedException.java
@@ -21,7 +21,7 @@ import java.io.IOException;
/**
* FTPConnectionClosedException is used to indicate the premature or
unexpected closing of an FTP connection resulting from a
- * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE
FTPReply.SERVICE_NOT_AVAILABLE } response (FTP reply code 421) to a failed FTP
command. This
+ * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE
FTPReply.SERVICE_NOT_AVAILABLE} response (FTP reply code 421) to a failed FTP
command. This
* exception is derived from IOException and therefore may be caught either as
an IOException or specifically as an FTPConnectionClosedException.
*
* @see FTP
diff --git a/src/main/java/org/apache/commons/net/imap/IMAPClient.java
b/src/main/java/org/apache/commons/net/imap/IMAPClient.java
index a1ede494..d645aaaa 100644
--- a/src/main/java/org/apache/commons/net/imap/IMAPClient.java
+++ b/src/main/java/org/apache/commons/net/imap/IMAPClient.java
@@ -391,7 +391,7 @@ public class IMAPClient extends IMAP {
/**
* Login to the IMAP server with the given user and password. You must
first connect to the server with
- * {@link org.apache.commons.net.SocketClient#connect connect } before
attempting to log in. A login attempt is only valid if the client is in the
+ * {@link org.apache.commons.net.SocketClient#connect connect} before
attempting to log in. A login attempt is only valid if the client is in the
* NOT_AUTH_STATE. After logging in, the client enters the AUTH_STATE.
*
* @param user The account name being logged in to.
diff --git a/src/main/java/org/apache/commons/net/io/Util.java
b/src/main/java/org/apache/commons/net/io/Util.java
index 198aa17a..b25b9c3a 100644
--- a/src/main/java/org/apache/commons/net/io/Util.java
+++ b/src/main/java/org/apache/commons/net/io/Util.java
@@ -43,7 +43,7 @@ import org.apache.commons.net.util.NetConstants;
public final class Util {
/**
- * The default buffer size ({@value}) used by {@link #copyStream
copyStream } and {@link #copyReader copyReader} and by the
copyReader/copyStream methods if
+ * The default buffer size ({@value}) used by {@link #copyStream
copyStream} and {@link #copyReader copyReader} and by the copyReader/copyStream
methods if
* a zero or negative buffer size is supplied.
*/
public static final int DEFAULT_COPY_BUFFER_SIZE = 1024;
diff --git a/src/main/java/org/apache/commons/net/nntp/NNTP.java
b/src/main/java/org/apache/commons/net/nntp/NNTP.java
index cd749229..f1f42abd 100644
--- a/src/main/java/org/apache/commons/net/nntp/NNTP.java
+++ b/src/main/java/org/apache/commons/net/nntp/NNTP.java
@@ -38,13 +38,13 @@ import org.apache.commons.net.io.CRLFLineReader;
* <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
+ * 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} is
* a subclass of {@code IOException} 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} 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 }.
+ * 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>
* <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
@@ -275,7 +275,7 @@ public class NNTP extends SocketClient {
/**
* Gets 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
+ * {@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.
*
* @return The integer value of the reply code of the fetched NNTP reply.
in response to the command.
@@ -583,7 +583,7 @@ public class NNTP extends SocketClient {
/**
* 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 }.
+ * information, the actual reply text can be accessed by calling {@link
#getReplyString getReplyString}.
*
* @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.
@@ -598,7 +598,7 @@ public class NNTP extends SocketClient {
/**
* 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 }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString}.
*
* @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.
@@ -614,7 +614,7 @@ public class NNTP extends SocketClient {
/**
* 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 }.
+ * information, the actual reply text can be accessed by calling {@link
#getReplyString getReplyString}.
*
* @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.
@@ -629,7 +629,7 @@ public class NNTP extends SocketClient {
/**
* 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 }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString}.
*
* @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.
diff --git a/src/main/java/org/apache/commons/net/nntp/NNTPClient.java
b/src/main/java/org/apache/commons/net/nntp/NNTPClient.java
index 6bb2f138..bd19b841 100644
--- a/src/main/java/org/apache/commons/net/nntp/NNTPClient.java
+++ b/src/main/java/org/apache/commons/net/nntp/NNTPClient.java
@@ -35,20 +35,20 @@ import org.apache.commons.net.util.NetConstants;
/**
* NNTPClient encapsulates all the functionality necessary to post and
retrieve articles from an NNTP server. As with all classes derived from
- * {@link org.apache.commons.net.SocketClient}, you must first connect to the
server with {@link org.apache.commons.net.SocketClient#connect connect } before
+ * {@link org.apache.commons.net.SocketClient}, you must first connect to the
server with {@link org.apache.commons.net.SocketClient#connect connect} before
* doing anything, and finally {@link
org.apache.commons.net.nntp.NNTP#disconnect disconnect()} after you're
completely finished interacting with the server.
* Remember that the {@link org.apache.commons.net.nntp.NNTP#isAllowedToPost
isAllowedToPost()} method is defined in {@link
org.apache.commons.net.nntp.NNTP}.
* <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
+ * 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} is
* a subclass of {@code IOException} 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} catch block. When you
encounter an
* {@link org.apache.commons.net.nntp.NNTPConnectionClosedException} , you
must disconnect the connection with
* {@link org.apache.commons.net.nntp.NNTP#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
org.apache.commons.net.nntp.NNTP#getReplyCode getReplyCode } and
- * {@link org.apache.commons.net.nntp.NNTP#getReplyString getReplyString }.
+ * the last reply code and text with {@link
org.apache.commons.net.nntp.NNTP#getReplyCode getReplyCode} and
+ * {@link org.apache.commons.net.nntp.NNTP#getReplyString getReplyString}.
* </p>
* <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
diff --git
a/src/main/java/org/apache/commons/net/nntp/NNTPConnectionClosedException.java
b/src/main/java/org/apache/commons/net/nntp/NNTPConnectionClosedException.java
index cd63833a..83ddcefd 100644
---
a/src/main/java/org/apache/commons/net/nntp/NNTPConnectionClosedException.java
+++
b/src/main/java/org/apache/commons/net/nntp/NNTPConnectionClosedException.java
@@ -21,7 +21,7 @@ import java.io.IOException;
/**
* NNTPConnectionClosedException is used to indicate the premature or
unexpected closing of an NNTP connection resulting from a
- * {@link org.apache.commons.net.nntp.NNTPReply#SERVICE_DISCONTINUED
NNTPReply.SERVICE_DISCONTINUED } response (NNTP reply code 400) to a failed
NNTP command.
+ * {@link org.apache.commons.net.nntp.NNTPReply#SERVICE_DISCONTINUED
NNTPReply.SERVICE_DISCONTINUED} response (NNTP reply code 400) to a failed NNTP
command.
* This exception is derived from IOException and therefore may be caught
either as an IOException or specifically as an NNTPConnectionClosedException.
*
* @see NNTP
diff --git
a/src/main/java/org/apache/commons/net/nntp/NewGroupsOrNewsQuery.java
b/src/main/java/org/apache/commons/net/nntp/NewGroupsOrNewsQuery.java
index 81e4a98f..5883e720 100644
--- a/src/main/java/org/apache/commons/net/nntp/NewGroupsOrNewsQuery.java
+++ b/src/main/java/org/apache/commons/net/nntp/NewGroupsOrNewsQuery.java
@@ -22,7 +22,7 @@ import java.util.Objects;
/**
* The NewGroupsOrNewsQuery class. This is used to issue NNTP NEWGROUPS and
NEWNEWS queries, implemented by
- * {@link org.apache.commons.net.nntp.NNTPClient#listNewNewsgroups
listNewNewsGroups } and {@link
org.apache.commons.net.nntp.NNTPClient#listNewNews listNewNews
+ * {@link org.apache.commons.net.nntp.NNTPClient#listNewNewsgroups
listNewNewsGroups} and {@link
org.apache.commons.net.nntp.NNTPClient#listNewNews listNewNews
* } respectively. It prevents you from having to format date, time,
distribution, and newgroup arguments.
* <p>
* You might use the class as follows:
diff --git a/src/main/java/org/apache/commons/net/nntp/NewsgroupInfo.java
b/src/main/java/org/apache/commons/net/nntp/NewsgroupInfo.java
index db6cb386..e68209f3 100644
--- a/src/main/java/org/apache/commons/net/nntp/NewsgroupInfo.java
+++ b/src/main/java/org/apache/commons/net/nntp/NewsgroupInfo.java
@@ -19,8 +19,8 @@ package org.apache.commons.net.nntp;
/**
* NewsgroupInfo stores information pertaining to a newsgroup returned by the
NNTP GROUP, LIST, and NEWGROUPS commands, implemented by
- * {@link org.apache.commons.net.nntp.NNTPClient#selectNewsgroup
selectNewsgroup } , {@link
org.apache.commons.net.nntp.NNTPClient#listNewsgroups listNewsgroups
- * } , and {@link org.apache.commons.net.nntp.NNTPClient#listNewNewsgroups
listNewNewsgroups } respectively.
+ * {@link org.apache.commons.net.nntp.NNTPClient#selectNewsgroup
selectNewsgroup} , {@link org.apache.commons.net.nntp.NNTPClient#listNewsgroups
listNewsgroups
+ * } , and {@link org.apache.commons.net.nntp.NNTPClient#listNewNewsgroups
listNewNewsgroups} respectively.
*
* @see NNTPClient
*/
diff --git a/src/main/java/org/apache/commons/net/pop3/POP3.java
b/src/main/java/org/apache/commons/net/pop3/POP3.java
index fcd73ba9..6e3fb173 100644
--- a/src/main/java/org/apache/commons/net/pop3/POP3.java
+++ b/src/main/java/org/apache/commons/net/pop3/POP3.java
@@ -181,7 +181,7 @@ public class POP3 extends SocketClient {
* Gets the reply to the last command sent to the server. The value is a
single string containing all the reply lines including newlines. If the reply is
* a single line, but its format ndicates it should be a multiline reply,
then you must call {@link #getAdditionalReply getAdditionalReply()} to fetch the
* rest of the reply, and then call {@code getReplyString} again. You only
have to worry about this if you are implementing your own client using the
- * {@link #sendCommand sendCommand } methods.
+ * {@link #sendCommand sendCommand} methods.
*
* @return The last server response.
*/
@@ -200,7 +200,7 @@ public class POP3 extends SocketClient {
* Gets an array of lines received as a reply to the last command sent to
the server. The lines have end of lines truncated. If the reply is a single
* line, but its format ndicates it should be a multiline reply, then you
must call {@link #getAdditionalReply getAdditionalReply()} to fetch the rest of
* the reply, and then call {@code getReplyStrings} again. You only have
to worry about this if you are implementing your own client using the
- * {@link #sendCommand sendCommand } methods.
+ * {@link #sendCommand sendCommand} methods.
*
* @return The last server response.
*/
diff --git a/src/main/java/org/apache/commons/net/pop3/POP3Client.java
b/src/main/java/org/apache/commons/net/pop3/POP3Client.java
index 7f92b3a2..c1229be4 100644
--- a/src/main/java/org/apache/commons/net/pop3/POP3Client.java
+++ b/src/main/java/org/apache/commons/net/pop3/POP3Client.java
@@ -272,8 +272,8 @@ public class POP3Client extends POP3 {
* parse out the timestamp information yourself.
* <p>
* You must first connect to the server with {@link
org.apache.commons.net.SocketClient#connect connect} before attempting to log
in. A login attempt is
- * only valid if the client is in the {@link
org.apache.commons.net.pop3.POP3#AUTHORIZATION_STATE AUTHORIZATION_STATE }.
After logging in, the client enters
- * the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE }. After connecting, you must parse out the server specific
information
+ * only valid if the client is in the {@link
org.apache.commons.net.pop3.POP3#AUTHORIZATION_STATE AUTHORIZATION_STATE}.
After logging in, the client enters
+ * the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE}. After connecting, you must parse out the server specific
information
* to use as a timestamp, and pass that information to this method. The
secret is a shared secret known to you and the server. See RFC 1939 for more
details
* regarding the APOP command.
* </p>
@@ -325,8 +325,8 @@ public class POP3Client extends POP3 {
/**
* Logout of the POP3 server. To fully disconnect from the server you must
call {@link org.apache.commons.net.pop3.POP3#disconnect disconnect}. A logout
- * attempt is valid in any state. If the client is in the {@link
org.apache.commons.net.pop3.POP3#TRANSACTION_STATE TRANSACTION_STATE } , it
enters the
- * {@link org.apache.commons.net.pop3.POP3#UPDATE_STATE UPDATE_STATE } on
a successful logout.
+ * attempt is valid in any state. If the client is in the {@link
org.apache.commons.net.pop3.POP3#TRANSACTION_STATE TRANSACTION_STATE} , it
enters the
+ * {@link org.apache.commons.net.pop3.POP3#UPDATE_STATE UPDATE_STATE} on a
successful logout.
*
* @return True if the logout attempt was successful, false if not.
* @throws IOException If a network I/O error occurs in the process of
logging out.
@@ -341,7 +341,7 @@ public class POP3Client extends POP3 {
/**
* Send a NOOP command to the POP3 server. This is useful for keeping a
connection alive since most POP3 servers will time out after 10 minutes of
- * inactivity. A noop attempt will only succeed if the client is in the
{@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE TRANSACTION_STATE }.
+ * inactivity. A noop attempt will only succeed if the client is in the
{@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE TRANSACTION_STATE}.
*
* @return True if the noop attempt was successful, false if not.
* @throws IOException If a network I/O error occurs in the process of
sending the NOOP command.
@@ -355,7 +355,7 @@ public class POP3Client extends POP3 {
/**
* Reset the POP3 session. This is useful for undoing any message
deletions that may have been performed. A reset attempt can only succeed if the
client is
- * in the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE }.
+ * in the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE}.
*
* @return True if the reset attempt was successful, false if not.
* @throws IOException If a network I/O error occurs in the process of
sending the reset command.
@@ -369,7 +369,7 @@ public class POP3Client extends POP3 {
/**
* Retrieve a message from the POP3 server. A retrieve message attempt can
only succeed if the client is in the
- * {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE }
+ * {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE}
* <p>
* You must not issue any commands to the POP3 server (i.e., call any
other methods) until you finish reading the message from the returned
BufferedReader
* instance. The POP3 protocol uses the same stream for issuing commands
as it does for returning results. Therefore, the returned BufferedReader
actually
@@ -396,7 +396,7 @@ public class POP3Client extends POP3 {
/**
* Retrieve only the specified top number of lines of a message from the
POP3 server. A retrieve top lines attempt can only succeed if the client is in
the
- * {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE }
+ * {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
TRANSACTION_STATE}
* <p>
* You must not issue any commands to the POP3 server (i.e., call any
other methods) until you finish reading the message from the returned
BufferedReader
* instance. The POP3 protocol uses the same stream for issuing commands
as it does for returning results. Therefore, the returned BufferedReader
actually
diff --git a/src/main/java/org/apache/commons/net/smtp/SMTP.java
b/src/main/java/org/apache/commons/net/smtp/SMTP.java
index 3d26c25d..d8f97d52 100644
--- a/src/main/java/org/apache/commons/net/smtp/SMTP.java
+++ b/src/main/java/org/apache/commons/net/smtp/SMTP.java
@@ -39,13 +39,13 @@ import org.apache.commons.net.util.NetConstants;
* protocol and implement their own clients. A set of methods with names
corresponding to the SMTP command names are provided to facilitate this
interaction.
* <p>
* You should keep in mind that the SMTP server may choose to prematurely
close a connection for various reasons. The SMTP class will detect a premature
SMTP
- * server connection closing when it receives a {@link
org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE
SMTPReply.SERVICE_NOT_AVAILABLE } response to
+ * server connection closing when it receives a {@link
org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE
SMTPReply.SERVICE_NOT_AVAILABLE} response to
* a command. When that occurs, the SMTP class method encountering that reply
will throw an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException}.
* {@code SMTPConnectionClosedException} is a subclass of {@code IOException}
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} catch block. When you encounter an
* {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} , you
must disconnect the connection with
* {@link org.apache.commons.net.SocketClient#disconnect disconnect()} to
properly clean up the system resources used by SMTP. Before disconnecting, you
may
- * check the last reply code and text with {@link #getReplyCode getReplyCode
}, {@link #getReplyString getReplyString }, and {@link #getReplyStrings
+ * check the last reply code and text with {@link #getReplyCode getReplyCode},
{@link #getReplyString getReplyString}, and {@link #getReplyStrings
* getReplyStrings}.
* </p>
* <p>
@@ -174,7 +174,7 @@ public class SMTP extends SocketClient {
/**
* Gets a reply from the SMTP server and returns the integer reply code.
After calling this method, the actual reply text can be accessed from either
- * calling {@link #getReplyString getReplyString } or {@link
#getReplyStrings getReplyStrings }. Only use this method if you are
implementing your own SMTP
+ * calling {@link #getReplyString getReplyString} or {@link
#getReplyStrings getReplyStrings}. Only use this method if you are implementing
your own SMTP
* client or if you need to fetch a secondary response from the SMTP
server.
*
* @return The integer value of the reply code of the fetched SMTP reply.
@@ -434,7 +434,7 @@ public class SMTP extends SocketClient {
/**
* Sends an SMTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * information, the actual reply text can be accessed by calling {@link
#getReplyString getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The SMTPCommand constant corresponding to the SMTP
command to send.
* @return The integer value of the SMTP reply code returned by the server
in response to the command.
@@ -449,7 +449,7 @@ public class SMTP extends SocketClient {
/**
* Sends an SMTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The SMTPCommand constant corresponding to the SMTP
command to send.
* @param args The arguments to the SMTP command. If this parameter is
set to null, then the command is sent with no argument.
@@ -477,7 +477,7 @@ public class SMTP extends SocketClient {
/**
* Sends an SMTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * information, the actual reply text can be accessed by calling {@link
#getReplyString getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The text representation of the SMTP command to send.
* @return The integer value of the SMTP reply code returned by the server
in response to the command.
@@ -492,7 +492,7 @@ public class SMTP extends SocketClient {
/**
* Sends an SMTP 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 } or {@link #getReplyStrings getReplyStrings }.
+ * actual reply text can be accessed by calling {@link #getReplyString
getReplyString} or {@link #getReplyStrings getReplyStrings}.
*
* @param command The text representation of the SMTP command to send.
* @param args The arguments to the SMTP command. If this parameter is
set to null, then the command is sent with no argument.
diff --git a/src/main/java/org/apache/commons/net/smtp/SMTPClient.java
b/src/main/java/org/apache/commons/net/smtp/SMTPClient.java
index c0eecfa9..231334c8 100644
--- a/src/main/java/org/apache/commons/net/smtp/SMTPClient.java
+++ b/src/main/java/org/apache/commons/net/smtp/SMTPClient.java
@@ -26,8 +26,8 @@ import org.apache.commons.net.io.DotTerminatedMessageWriter;
/**
* SMTPClient encapsulates all the functionality necessary to send files
through an SMTP server. This class takes care of all low level details of
interacting
* with an SMTP server and provides a convenient higher level interface. As
with all classes derived from {@link org.apache.commons.net.SocketClient}, you
must
- * first connect to the server with {@link
org.apache.commons.net.SocketClient#connect connect } before doing anything,
and finally
- * {@link org.apache.commons.net.SocketClient#disconnect disconnect } after
you're completely finished interacting with the server. Then you need to check
the
+ * first connect to the server with {@link
org.apache.commons.net.SocketClient#connect connect} before doing anything, and
finally
+ * {@link org.apache.commons.net.SocketClient#disconnect disconnect} after
you're completely finished interacting with the server. Then you need to check
the
* SMTP reply code to see if the connection was successful. For example:
*
* <pre>
@@ -66,17 +66,17 @@ import org.apache.commons.net.io.DotTerminatedMessageWriter;
* command methods in SMTPClient is such that they either return a boolean
value or some other value. The boolean methods return true on a successful
completion
* reply from the SMTP server and false on a reply resulting in an error
condition or failure. The methods returning a value other than boolean return a
value
* containing the higher level data produced by the SMTP command, or null if a
reply resulted in an error condition or failure. If you want to access the exact
- * SMTP reply code causing a success or failure, you must call {@link
org.apache.commons.net.smtp.SMTP#getReplyCode getReplyCode } after a success or
failure.
+ * SMTP reply code causing a success or failure, you must call {@link
org.apache.commons.net.smtp.SMTP#getReplyCode getReplyCode} after a success or
failure.
* </p>
* <p>
* You should keep in mind that the SMTP server may choose to prematurely
close a connection for various reasons. The SMTPClient class will detect a
premature
- * SMTP server connection closing when it receives a {@link
org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE
SMTPReply.SERVICE_NOT_AVAILABLE }
+ * SMTP server connection closing when it receives a {@link
org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE
SMTPReply.SERVICE_NOT_AVAILABLE}
* response to a command. When that occurs, the method encountering that reply
will throw an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException}.
* {@code SMTPConnectionClosedException} is a subclass of {@code IOException}
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} catch block. When you encounter an
* {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} , you
must disconnect the connection with {@link #disconnect disconnect()} to properly
* clean up the system resources used by SMTPClient. Before disconnecting, you
may check the last reply code and text with
- * {@link org.apache.commons.net.smtp.SMTP#getReplyCode getReplyCode }, {@link
org.apache.commons.net.smtp.SMTP#getReplyString getReplyString }, and
+ * {@link org.apache.commons.net.smtp.SMTP#getReplyCode getReplyCode}, {@link
org.apache.commons.net.smtp.SMTP#getReplyString getReplyString}, and
* {@link org.apache.commons.net.smtp.SMTP#getReplyStrings getReplyStrings}.
* </p>
* <p>
@@ -141,7 +141,7 @@ public class SMTPClient extends SMTP {
}
/**
- * At least one SMTPClient method ({@link #sendMessageData sendMessageData
}) does not complete the entire sequence of SMTP commands to complete a
+ * At least one SMTPClient method ({@link #sendMessageData
sendMessageData}) does not complete the entire sequence of SMTP commands to
complete a
* transaction. These types of commands require some action by the
programmer after the reception of a positive intermediate command. After the
programmer's
* code completes its actions, it must call this method to receive the
completion reply from the server and verify the success of the entire
transaction.
* <p>
@@ -333,7 +333,7 @@ public class SMTPClient extends SMTP {
/**
* Sends a short email without having to explicitly set the sender and
recipient(s). This method sets the sender and recipient
- * using {@link #setSender setSender } and {@link #addRecipient
addRecipient }, and then sends the message using {@link #sendShortMessageData
+ * using {@link #setSender setSender} and {@link #addRecipient
addRecipient}, and then sends the message using {@link #sendShortMessageData
* sendShortMessageData }.
*
* @param sender The email address of the sender.
diff --git a/src/main/java/org/apache/commons/net/smtp/SMTPCommand.java
b/src/main/java/org/apache/commons/net/smtp/SMTPCommand.java
index 14f514d7..54a2fd89 100644
--- a/src/main/java/org/apache/commons/net/smtp/SMTPCommand.java
+++ b/src/main/java/org/apache/commons/net/smtp/SMTPCommand.java
@@ -20,7 +20,7 @@ package org.apache.commons.net.smtp;
/**
* SMTPCommand stores a set of constants for SMTP command codes. To interpret
the meaning of the codes, familiarity with RFC 821 is assumed. The mnemonic
* constant names are transcriptions from the code descriptions of RFC 821.
For those who think in terms of the actual SMTP commands, a set of constants
such as
- * {@link #HELO HELO } are provided where the constant name is the same as the
SMTP command.
+ * {@link #HELO HELO} are provided where the constant name is the same as the
SMTP command.
*/
public final class SMTPCommand {
diff --git
a/src/main/java/org/apache/commons/net/smtp/SMTPConnectionClosedException.java
b/src/main/java/org/apache/commons/net/smtp/SMTPConnectionClosedException.java
index 3b6a1fad..18afce0e 100644
---
a/src/main/java/org/apache/commons/net/smtp/SMTPConnectionClosedException.java
+++
b/src/main/java/org/apache/commons/net/smtp/SMTPConnectionClosedException.java
@@ -21,7 +21,7 @@ import java.io.IOException;
/**
* SMTPConnectionClosedException is used to indicate the premature or
unexpected closing of an SMTP connection resulting from a
- * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE
SMTPReply.SERVICE_NOT_AVAILABLE } response (SMTP reply code 421) to a failed
SMTP command.
+ * {@link org.apache.commons.net.smtp.SMTPReply#SERVICE_NOT_AVAILABLE
SMTPReply.SERVICE_NOT_AVAILABLE} response (SMTP reply code 421) to a failed
SMTP command.
* This exception is derived from IOException and therefore may be caught
either as an IOException or specifically as an SMTPConnectionClosedException.
*
*
diff --git a/src/main/java/org/apache/commons/net/telnet/TelnetClient.java
b/src/main/java/org/apache/commons/net/telnet/TelnetClient.java
index 066cb999..16b8dda9 100644
--- a/src/main/java/org/apache/commons/net/telnet/TelnetClient.java
+++ b/src/main/java/org/apache/commons/net/telnet/TelnetClient.java
@@ -31,7 +31,7 @@ import org.apache.commons.io.IOUtils;
* <p>
* The class can be used by first connecting to a server using the
SocketClient {@link org.apache.commons.net.SocketClient#connect connect}
method. Then an
* InputStream and OutputStream for sending and receiving data over the Telnet
connection can be obtained by using the {@link #getInputStream getInputStream()}
- * and {@link #getOutputStream getOutputStream()} methods. When you finish
using the streams, you must call {@link #disconnect disconnect } rather than
simply
+ * and {@link #getOutputStream getOutputStream()} methods. When you finish
using the streams, you must call {@link #disconnect disconnect} rather than
simply
* closing the streams.
* </p>
*/
diff --git a/src/main/java/org/apache/commons/net/time/TimeTCPClient.java
b/src/main/java/org/apache/commons/net/time/TimeTCPClient.java
index ba244edf..23ddc667 100644
--- a/src/main/java/org/apache/commons/net/time/TimeTCPClient.java
+++ b/src/main/java/org/apache/commons/net/time/TimeTCPClient.java
@@ -25,8 +25,8 @@ import org.apache.commons.net.SocketClient;
/**
* The TimeTCPClient class is a TCP implementation of a client for the Time
protocol described in RFC 868. To use the class, merely establish a connection
with
- * {@link org.apache.commons.net.SocketClient#connect connect } and call
either {@link #getTime getTime()} or {@link #getDate getDate()} to retrieve the
time,
- * then call {@link org.apache.commons.net.SocketClient#disconnect disconnect
} to close the connection properly.
+ * {@link org.apache.commons.net.SocketClient#connect connect} and call either
{@link #getTime getTime()} or {@link #getDate getDate()} to retrieve the time,
+ * then call {@link org.apache.commons.net.SocketClient#disconnect disconnect}
to close the connection properly.
*
*
* @see TimeUDPClient
@@ -51,8 +51,8 @@ public final class TimeTCPClient extends SocketClient {
/**
* Gets the time from the server and returns a Java Date containing the
time converted to the local time zone.
* <p>
- * The server will have closed the connection at this point, so you should
call {@link org.apache.commons.net.SocketClient#disconnect disconnect } after
- * calling this method. To retrieve another time, you must initiate
another connection with {@link org.apache.commons.net.SocketClient#connect
connect }
+ * The server will have closed the connection at this point, so you should
call {@link org.apache.commons.net.SocketClient#disconnect disconnect} after
+ * calling this method. To retrieve another time, you must initiate
another connection with {@link org.apache.commons.net.SocketClient#connect
connect}
* before calling {@code getDate()} again.
* </p>
*
@@ -67,8 +67,8 @@ public final class TimeTCPClient extends SocketClient {
* Gets the time from the server and returns it. The time is the number of
seconds since 00:00 (midnight) 1 January 1900 GMT, as specified by RFC 868.
* This method reads the raw 32-bit big-endian unsigned integer from the
server, converts it to a Java long, and returns the value.
* <p>
- * The server will have closed the connection at this point, so you should
call {@link org.apache.commons.net.SocketClient#disconnect disconnect } after
- * calling this method. To retrieve another time, you must initiate
another connection with {@link org.apache.commons.net.SocketClient#connect
connect }
+ * The server will have closed the connection at this point, so you should
call {@link org.apache.commons.net.SocketClient#disconnect disconnect} after
+ * calling this method. To retrieve another time, you must initiate
another connection with {@link org.apache.commons.net.SocketClient#connect
connect}
* before calling {@code getTime()} again.
* </p>
*
diff --git a/src/main/java/org/apache/commons/net/time/TimeUDPClient.java
b/src/main/java/org/apache/commons/net/time/TimeUDPClient.java
index a0f5e929..f25b6dd5 100644
--- a/src/main/java/org/apache/commons/net/time/TimeUDPClient.java
+++ b/src/main/java/org/apache/commons/net/time/TimeUDPClient.java
@@ -26,9 +26,9 @@ import org.apache.commons.net.DatagramSocketClient;
/**
* The TimeUDPClient class is a UDP implementation of a client for the Time
protocol described in RFC 868. To use the class, merely open a local datagram
socket
- * with {@link org.apache.commons.net.DatagramSocketClient#open open } and
call {@link #getTime getTime } or {@link #getTime getDate } to retrieve the
time.
- * Then call {@link org.apache.commons.net.DatagramSocketClient#close close }
to close the connection properly. Unlike
- * {@link org.apache.commons.net.time.TimeTCPClient}, successive calls to
{@link #getTime getTime } or {@link #getDate getDate } are permitted without
+ * with {@link org.apache.commons.net.DatagramSocketClient#open open} and call
{@link #getTime getTime} or {@link #getTime getDate} to retrieve the time.
+ * Then call {@link org.apache.commons.net.DatagramSocketClient#close close}
to close the connection properly. Unlike
+ * {@link org.apache.commons.net.time.TimeTCPClient}, successive calls to
{@link #getTime getTime} or {@link #getDate getDate} are permitted without
* re-establishing a connection. That is because UDP is a connectionless
protocol and the Time protocol is stateless.
*
*
