* Usage: NTPClient
* Example: NTPClient clock.psu.edu *
*/ public final class NTPClient { private static final NumberFormat numberFormat = new java.text.DecimalFormat("0.00"); public static void main(final String[] args) { if (args.length == 0) { System.err.println("Usage: NTPClientTimeInfo object and print its details.
*
* @param info TimeInfo object.
*/
public static void processResponse(final TimeInfo info) {
final NtpV3Packet message = info.getMessage();
final int stratum = message.getStratum();
final String refType;
if (stratum <= 0) {
refType = "(Unspecified or Unavailable)";
} else if (stratum == 1) {
refType = "(Primary Reference; e.g., GPS)"; // GPS, radio clock, etc.
} else {
refType = "(Secondary Reference; e.g. via NTP or SNTP)";
}
// stratum should be 0..15...
System.out.println(" Stratum: " + stratum + " " + refType);
final int version = message.getVersion();
final int li = message.getLeapIndicator();
System.out.println(" leap=" + li + ", version=" + version + ", precision=" + message.getPrecision());
System.out.println(" mode: " + message.getModeName() + " (" + message.getMode() + ")");
final int poll = message.getPoll();
// poll value typically btwn MINPOLL (4) and MAXPOLL (14)
System.out.println(" poll: " + (poll <= 0 ? 1 : (int) Math.pow(2, poll)) + " seconds" + " (2 ** " + poll + ")");
final double disp = message.getRootDispersionInMillisDouble();
System.out.println(" rootdelay=" + numberFormat.format(message.getRootDelayInMillisDouble()) + ", rootdispersion(ms): " + numberFormat.format(disp));
final int refId = message.getReferenceId();
String refAddr = NtpUtils.getHostAddress(refId);
String refName = null;
if (refId != 0) {
if (refAddr.equals("127.127.1.0")) {
refName = "LOCAL"; // This is the ref address for the Local Clock
} else if (stratum >= 2) {
// If reference id has 127.127 prefix then it uses its own reference clock
// defined in the form 127.127.clock-type.unit-num (e.g. 127.127.8.0 mode 5
// for GENERIC DCF77 AM; see refclock.htm from the NTP software distribution.
if (!refAddr.startsWith("127.127")) {
try {
final InetAddress addr = InetAddress.getByName(refAddr);
final String name = addr.getHostName();
if (name != null && !name.equals(refAddr)) {
refName = name;
}
} catch (final UnknownHostException e) {
// some stratum-2 servers sync to ref clock device but fudge stratum level higher... (e.g. 2)
// ref not valid host maybe it's a reference clock name?
// otherwise just show the ref IP address.
refName = NtpUtils.getReferenceClock(message);
}
}
} else if (version >= 3 && (stratum == 0 || stratum == 1)) {
refName = NtpUtils.getReferenceClock(message);
// refname usually have at least 3 characters (e.g. GPS, WWV, LCL, etc.)
}
// otherwise give up on naming the beast...
}
if (refName != null && refName.length() > 1) {
refAddr += " (" + refName + ")";
}
System.out.println(" Reference Identifier:\t" + refAddr);
final TimeStamp refNtpTime = message.getReferenceTimeStamp();
System.out.println(" Reference Timestamp:\t" + refNtpTime + " " + refNtpTime.toDateString());
// Originate Time is time request sent by client (t1)
final TimeStamp origNtpTime = message.getOriginateTimeStamp();
System.out.println(" Originate Timestamp:\t" + origNtpTime + " " + origNtpTime.toDateString());
final long destTimeMillis = info.getReturnTime();
// Receive Time is time request received by server (t2)
final TimeStamp rcvNtpTime = message.getReceiveTimeStamp();
System.out.println(" Receive Timestamp:\t" + rcvNtpTime + " " + rcvNtpTime.toDateString());
// Transmit time is time reply sent by server (t3)
final TimeStamp xmitNtpTime = message.getTransmitTimeStamp();
System.out.println(" Transmit Timestamp:\t" + xmitNtpTime + " " + xmitNtpTime.toDateString());
// Destination time is time reply received by client (t4)
final TimeStamp destNtpTime = TimeStamp.getNtpTime(destTimeMillis);
System.out.println(" Destination Timestamp:\t" + destNtpTime + " " + destNtpTime.toDateString());
info.computeDetails(); // compute offset/delay if not already done
final Long offsetMillis = info.getOffset();
final Long delayMillis = info.getDelay();
final String delay = delayMillis == null ? "N/A" : delayMillis.toString();
final String offset = offsetMillis == null ? "N/A" : offsetMillis.toString();
System.out.println(" Roundtrip delay(ms)=" + delay + ", clock offset(ms)=" + offset); // offset in ms
}
}
SimpleNTPServer.java 0000664 0000000 0000000 00000015740 14340477222 0034125 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/examples/ntp /*
* 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.examples.ntp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import org.apache.commons.net.ntp.NtpUtils;
import org.apache.commons.net.ntp.NtpV3Impl;
import org.apache.commons.net.ntp.NtpV3Packet;
import org.apache.commons.net.ntp.TimeStamp;
/**
* The SimpleNTPServer class is a UDP implementation of a server for the Network Time Protocol (NTP) version 3 as described in RFC 1305. It is a minimal NTP
* server that doesn't actually adjust the time but only responds to NTP datagram requests with response sent back to originating host with info filled out
* using the current clock time. To be used for debugging or testing.
*
* To prevent this from interfering with the actual NTP service it can be run from any local port.
*/
public class SimpleNTPServer implements Runnable {
public static void main(final String[] args) {
int port = NtpV3Packet.NTP_PORT;
if (args.length != 0) {
try {
port = Integer.parseInt(args[0]);
} catch (final NumberFormatException nfe) {
nfe.printStackTrace();
}
}
final SimpleNTPServer timeServer = new SimpleNTPServer(port);
try {
timeServer.start();
} catch (final IOException e) {
e.printStackTrace();
}
}
private int port;
private volatile boolean running;
private boolean started;
private DatagramSocket socket;
/**
* Creates SimpleNTPServer listening on default NTP port.
*/
public SimpleNTPServer() {
this(NtpV3Packet.NTP_PORT);
}
/**
* Creates SimpleNTPServer.
*
* @param port the local port the server socket is bound to, or zero for a system selected free port.
* @throws IllegalArgumentException if port number less than 0
*/
public SimpleNTPServer(final int port) {
if (port < 0) {
throw new IllegalArgumentException();
}
this.port = port;
}
/**
* Connects to server socket and listen for client connections.
*
* @throws IOException if an I/O error occurs when creating the socket.
*/
public void connect() throws IOException {
if (socket == null) {
socket = new DatagramSocket(port);
// port = 0 is bound to available free port
if (port == 0) {
port = socket.getLocalPort();
}
System.out.println("Running NTP service on port " + port + "/UDP");
}
}
public int getPort() {
return port;
}
/**
* Handles incoming packet. If NTP packet is client-mode then respond to that host with a NTP response packet otherwise ignore.
*
* @param request incoming DatagramPacket
* @param rcvTime time packet received
*
* @throws IOException if an I/O error occurs.
*/
protected void handlePacket(final DatagramPacket request, final long rcvTime) throws IOException {
final NtpV3Packet message = new NtpV3Impl();
message.setDatagramPacket(request);
System.out.printf("NTP packet from %s mode=%s%n", request.getAddress().getHostAddress(), NtpUtils.getModeName(message.getMode()));
if (message.getMode() == NtpV3Packet.MODE_CLIENT) {
final NtpV3Packet response = new NtpV3Impl();
response.setStratum(1);
response.setMode(NtpV3Packet.MODE_SERVER);
response.setVersion(NtpV3Packet.VERSION_3);
response.setPrecision(-20);
response.setPoll(0);
response.setRootDelay(62);
response.setRootDispersion((int) (16.51 * 65.536));
// originate time as defined in RFC-1305 (t1)
response.setOriginateTimeStamp(message.getTransmitTimeStamp());
// Receive Time is time request received by server (t2)
response.setReceiveTimeStamp(TimeStamp.getNtpTime(rcvTime));
response.setReferenceTime(response.getReceiveTimeStamp());
response.setReferenceId(0x4C434C00); // LCL (Undisciplined Local Clock)
// Transmit time is time reply sent by server (t3)
response.setTransmitTime(TimeStamp.getNtpTime(System.currentTimeMillis()));
final DatagramPacket dp = response.getDatagramPacket();
dp.setPort(request.getPort());
dp.setAddress(request.getAddress());
socket.send(dp);
}
// otherwise if received packet is other than CLIENT mode then ignore it
}
/**
* Returns state of whether time service is running.
*
* @return true if time service is running
*/
public boolean isRunning() {
return running;
}
/**
* Returns state of whether time service is running.
*
* @return true if time service is running
*/
public boolean isStarted() {
return started;
}
/**
* Main method to service client connections.
*/
@Override
public void run() {
running = true;
final byte buffer[] = new byte[48];
final DatagramPacket request = new DatagramPacket(buffer, buffer.length);
do {
try {
socket.receive(request);
final long rcvTime = System.currentTimeMillis();
handlePacket(request, rcvTime);
} catch (final IOException e) {
if (running) {
e.printStackTrace();
}
// otherwise socket thrown exception during shutdown
}
} while (running);
}
/**
* Starts time service and provide time to client connections.
*
* @throws IOException if an I/O error occurs when creating the socket.
*/
public void start() throws IOException {
if (socket == null) {
connect();
}
if (!started) {
started = true;
new Thread(this).start();
}
}
/**
* Closes server socket and stop listening.
*/
public void stop() {
running = false;
if (socket != null) {
socket.close(); // force closing of the socket
socket = null;
}
started = false;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/examples/ntp/TimeClient.java 0000664 0000000 0000000 00000005571 14340477222 0033240 0 ustar 00root root 0000000 0000000 /*
* 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.examples.ntp;
import java.io.IOException;
import java.net.InetAddress;
import org.apache.commons.net.time.TimeTCPClient;
import org.apache.commons.net.time.TimeUDPClient;
/**
* This is an example program demonstrating how to use the TimeTCPClient and TimeUDPClient classes. This program connects to the default time service port of a
* specified server, retrieves the time, and prints it to standard output. See the spec for
* details. The default is to use the TCP port. Use the -udp flag to use the UDP port.
*
* Usage: TimeClient [-udp]
* These do not form part of the public API and may change without notice. */ package org.apache.commons.net.examples; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/examples/telnet/ 0000775 0000000 0000000 00000000000 14340477222 0031022 5 ustar 00root root 0000000 0000000 TelnetClientExample.java 0000664 0000000 0000000 00000030336 14340477222 0035521 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/examples/telnet /* * 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.examples.telnet; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.StringTokenizer; import org.apache.commons.net.telnet.EchoOptionHandler; import org.apache.commons.net.telnet.InvalidTelnetOptionException; import org.apache.commons.net.telnet.SimpleOptionHandler; import org.apache.commons.net.telnet.SuppressGAOptionHandler; import org.apache.commons.net.telnet.TelnetClient; import org.apache.commons.net.telnet.TelnetNotificationHandler; import org.apache.commons.net.telnet.TerminalTypeOptionHandler; /** * This is a simple example of use of TelnetClient. An external option handler (SimpleTelnetOptionHandler) is used. Initial configuration requested by * TelnetClient will be: WILL ECHO, WILL SUPPRESS-GA, DO SUPPRESS-GA. VT100 terminal type will be subnegotiated. *
* Also, use of the sendAYT(), getLocalOptionState(), getRemoteOptionState() is demonstrated. When connected, type AYT to send an AYT command to the server and
* see the result. Type OPT to see a report of the state of the first 25 options.
*/
public class TelnetClientExample implements Runnable, TelnetNotificationHandler {
private static TelnetClient tc;
/**
* Main for the TelnetClientExample.
*
* @param args input params
* @throws Exception on error
*/
public static void main(final String[] args) throws Exception {
FileOutputStream fout = null;
if (args.length < 1) {
System.err.println("Usage: TelnetClientExample
* Usage: chargen [-udp]
* Usage: daytime [-udp]
* Usage: echo [-udp]
* The -l flag is used to request long output from the server.
*/
public final class finger {
public static void main(final String[] args) {
boolean longOutput = false;
int arg = 0, index;
String handle, host;
final FingerClient finger;
InetAddress address = null;
// Get flags. If an invalid flag is present, exit with usage message.
while (arg < args.length && args[arg].startsWith("-")) {
if (args[arg].equals("-l")) {
longOutput = true;
} else {
System.err.println("usage: finger [-l] [[[handle][@
* Usage: rdate [-udp]
* Example: java rexec myhost myusername mypassword "ps -aux"
*
* Usage: rexec
* On Unix systems you will not be able to use the rshell capability unless the process runs as root since only root can bind port addresses lower than 1024.
*
* JVM's using green threads will likely have problems if the rlogin daemon requests a password. This program is merely a demonstration and is not suitable for
* use as an application, especially given that it relies on line buffered input from System.in. The best way to run this example is probably from a Win95 dos
* box into a Unix host.
*
* Example: java rlogin myhost localusername remoteusername vt100
*
* Usage: rlogin
* On Unix systems you will not be able to use the rshell capability unless the process runs as root since only root can bind port addresses lower than 1024.
*
* Example: java rshell myhost localusername remoteusername "ps -aux"
*
* Usage: rshell
* To derive the full benefits of the FTP class requires some knowledge of the FTP protocol defined in RFC 959. However, there is no reason why you should have
* to use the FTP class. The {@link org.apache.commons.net.ftp.FTPClient} class, derived from FTP, implements all the functionality required of an FTP client.
* The FTP class is made public to provide access to various FTP constants and to make it easier for adventurous programmers (or those with special needs) to
* interact with the FTP protocol and implement their own clients. A set of methods with names corresponding to the FTP command names are provided to facilitate
* this interaction.
*
* 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
* method encountering that reply will throw an {@link org.apache.commons.net.ftp.FTPConnectionClosedException} .
* 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 FTPClient
* @see FTPConnectionClosedException
* @see org.apache.commons.net.MalformedServerReplyException
*/
public class FTP extends SocketClient {
/** The default FTP data port (20). */
public static final int DEFAULT_DATA_PORT = 20;
/** The default FTP control port (21). */
public static final int DEFAULT_PORT = 21;
/**
* A constant used to indicate the file(s) being transferred should be treated as ASCII. This is the default file type. All constants ending in
*
* The default is true, which requires the 3 digit code be followed by space and some text.
* Please note that this has to be set before the connection is established.
*
* @param encoding The new character encoding for the control connection.
*/
public void setControlEncoding(final String encoding) {
_controlEncoding = encoding;
}
/**
* Set strict multiline parsing.
*
* @param strictMultilineParsing the setting
* @since 2.0
*/
public void setStrictMultilineParsing(final boolean strictMultilineParsing) {
this.strictMultilineParsing = strictMultilineParsing;
}
/**
* Set strict non-multiline parsing.
*
* If true, it requires the 3 digit code be followed by space and some text.
* This should not be required by a well-behaved FTP server
* Immediately after connecting is the only real time you need to check the reply code (because connect is of type void). The convention for all the FTP command
* 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.
*
* The default settings for FTPClient are for it to use
*
* Because the handling of sockets on different platforms can differ significantly, the FTPClient automatically issues a new PORT (or EPRT) command prior to
* every transfer requiring that the server connect to the client's data port. This ensures identical problem-free behavior on Windows, Unix, and Macintosh
* platforms. Additionally, it relieves programmers from having to issue the PORT (or EPRT) command themselves and dealing with platform dependent issues.
*
* Additionally, for security purposes, all data connections to the client are verified to ensure that they originated from the intended party (host and port).
* If a data connection is initiated by an unexpected party, the command will close the socket and throw an IOException. You may disable this behavior with
* {@link #setRemoteVerificationEnabled setRemoteVerificationEnabled()}.
*
* 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
* method encountering that reply will throw an {@link org.apache.commons.net.ftp.FTPConnectionClosedException} .
* 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.
*
* Listing API Examples Both paged and unpaged examples of directory listings are available, as follows:
*
* Unpaged (whole list) access, using a parser accessible by auto-detect:
*
*
* Paged access, using a parser not accessible by auto-detect. The class defined in the first parameter of initateListParsing should be derived from
* org.apache.commons.net.FTPFileEntryParser:
*
*
* Paged access, using a parser accessible by auto-detect:
*
*
* For examples of using FTPClient on servers whose directory listings
*
* Control channel keep-alive feature:
*
* Please note: this does not apply to the methods where the user is responsible for writing or reading the data stream, i.e.
* {@link #retrieveFileStream(String)} , {@link #storeFileStream(String)} and the other xxxFileStream methods
*
* During file transfers, the data connection is busy, but the control connection is idle. FTP servers know that the control connection is in use, so won't
* close it through lack of activity, but it's a lot harder for network routers to know that the control and data connections are associated with each other.
* Some routers may treat the control connection as idle, and disconnect it if the transfer over the data connection takes longer than the allowable idle time
* for the router.
* The implementation currently uses a {@link CopyStreamListener} which is passed to the
* {@link Util#copyStream(InputStream, OutputStream, int, long, CopyStreamListener, boolean)} method, so the timing is partially dependent on how long each
* block transfer takes.
*
* This keep-alive feature is optional; if it does not help or causes problems then don't use it.
*
* @see #FTP_SYSTEM_TYPE
* @see #SYSTEM_TYPE_PROPERTIES
* @see FTP
* @see FTPConnectionClosedException
* @see FTPFileEntryParser
* @see FTPFileEntryParserFactory
* @see DefaultFTPFileEntryParserFactory
* @see FTPClientConfig
* @see org.apache.commons.net.MalformedServerReplyException
*/
public class FTPClient extends FTP implements Configurable {
// @since 3.0
private static class CSL implements CopyStreamListener {
private final FTPClient parent;
private final long idleMillis;
private final int currentSoTimeoutMillis;
private long lastIdleTimeMillis = System.currentTimeMillis();
private int notAcked;
private int acksAcked;
private int ioErrors;
CSL(final FTPClient parent, final Duration idleDuration, final Duration maxWaitDuration) throws SocketException {
this.idleMillis = idleDuration.toMillis();
this.parent = parent;
this.currentSoTimeoutMillis = parent.getSoTimeout();
parent.setSoTimeout(DurationUtils.toMillisInt(maxWaitDuration));
}
@Override
public void bytesTransferred(final CopyStreamEvent event) {
bytesTransferred(event.getTotalBytesTransferred(), event.getBytesTransferred(), event.getStreamSize());
}
@Override
public void bytesTransferred(final long totalBytesTransferred, final int bytesTransferred, final long streamSize) {
final long nowMillis = System.currentTimeMillis();
if (nowMillis - lastIdleTimeMillis > idleMillis) {
try {
parent.__noop();
acksAcked++;
} catch (final SocketTimeoutException e) {
notAcked++;
} catch (final IOException e) {
ioErrors++;
// Ignored
}
lastIdleTimeMillis = nowMillis;
}
}
int[] cleanUp() throws IOException {
final int remain = notAcked;
try {
while (notAcked > 0) {
parent.getReply(); // we do want to see these
notAcked--; // only decrement if actually received
}
} catch (final SocketTimeoutException e) { // NET-584
// ignored
} finally {
parent.setSoTimeout(currentSoTimeoutMillis);
}
return new int[] { acksAcked, remain, notAcked, ioErrors }; // debug counts
}
}
/**
* Strategy interface for updating host names received from FTP server for passive NAT workaround.
*
* @since 3.6
*/
public interface HostnameResolver {
String resolve(String hostname) throws UnknownHostException;
}
/**
* Default strategy for passive NAT workaround (site-local replies are replaced.)
*
* @since 3.6
*/
public static class NatServerResolverImpl implements HostnameResolver {
private final FTPClient client;
public NatServerResolverImpl(final FTPClient client) {
this.client = client;
}
@Override
public String resolve(final String hostname) throws UnknownHostException {
String newHostname = hostname;
final InetAddress host = InetAddress.getByName(newHostname);
// reply is a local address, but target is not - assume NAT box changed the PASV reply
if (host.isSiteLocalAddress()) {
final InetAddress remote = this.client.getRemoteAddress();
if (!remote.isSiteLocalAddress()) {
newHostname = remote.getHostAddress();
}
}
return newHostname;
}
}
private static class PropertiesSingleton {
static final Properties PROPERTIES;
static {
final InputStream resourceAsStream = FTPClient.class.getResourceAsStream(SYSTEM_TYPE_PROPERTIES);
Properties p = null;
if (resourceAsStream != null) {
p = new Properties();
try {
p.load(resourceAsStream);
} catch (final IOException e) {
// Ignored
} finally {
try {
resourceAsStream.close();
} catch (final IOException e) {
// Ignored
}
}
}
PROPERTIES = p;
}
}
/**
* The system property ({@value}) which can be used to override the system type.
* According to RFC959 (http://www.ietf.org/rfc/rfc959.txt), it should be the same as for MKD i.e. {@code 257
* However, see NET-442 for an exception.
*
* @param reply
* @return the pathname, without enclosing quotes, or the full string after the reply code and space if the syntax is invalid (i.e. enclosing quotes are
* missing or embedded quotes are not doubled)
*/
// package protected for access by test cases
static String parsePathname(final String reply) {
final String param = reply.substring(REPLY_CODE_LEN + 1);
if (param.startsWith("\"")) {
final StringBuilder sb = new StringBuilder();
boolean quoteSeen = false;
// start after initial quote
for (int i = 1; i < param.length(); i++) {
final char ch = param.charAt(i);
if (ch == '"') {
if (quoteSeen) {
sb.append(ch);
quoteSeen = false;
} else {
// don't output yet, in case doubled
quoteSeen = true;
}
} else {
if (quoteSeen) { // found lone trailing quote within string
return sb.toString();
}
sb.append(ch); // just another character
}
}
if (quoteSeen) { // found lone trailing quote at end of string
return sb.toString();
}
}
// malformed reply, return all after reply code and space
return param;
}
private int dataConnectionMode;
private Duration dataTimeout;
private int passivePort;
private String passiveHost;
private final Random random;
private int activeMinPort;
private int activeMaxPort;
private InetAddress activeExternalHost;
/** overrides __activeExternalHost in EPRT/PORT commands. */
private InetAddress reportActiveExternalHost;
/** The address to bind to on passive connections, if necessary. */
private InetAddress passiveLocalHost;
private int fileType;
@SuppressWarnings("unused") // fields are written, but currently not read
private int fileFormat;
@SuppressWarnings("unused") // field is written, but currently not read
private int fileStructure;
@SuppressWarnings("unused") // field is written, but currently not read
private int fileTransferMode;
private boolean remoteVerificationEnabled;
private long restartOffset;
private FTPFileEntryParserFactory parserFactory;
private int bufferSize; // buffersize for buffered data streams
private int sendDataSocketBufferSize;
private int receiveDataSocketBufferSize;
private boolean listHiddenFiles;
private boolean useEPSVwithIPv4; // whether to attempt EPSV with an IPv4 connection
// __systemName is a cached value that should not be referenced directly
// except when assigned in getSystemName and __initDefaults.
private String systemName;
// __entryParser is a cached value that should not be referenced directly
// except when assigned in listFiles(String, String) and __initDefaults.
private FTPFileEntryParser entryParser;
// Key used to create the parser; necessary to ensure that the parser type is not ignored
private String entryParserKey;
private FTPClientConfig configuration;
// Listener used by store/retrieve methods to handle keepalive
private CopyStreamListener copyStreamListener;
// How long to wait before sending another control keep-alive message
private Duration controlKeepAliveTimeout = Duration.ZERO;
// How long to wait for keepalive message replies before continuing
// Most FTP servers don't seem to support concurrent control and data connection usage
private Duration controlKeepAliveReplyTimeout = Duration.ofSeconds(1);
// Debug counts for NOOP acks
private int[] cslDebug;
/**
* Enable or disable replacement of internal IP in passive mode. Default enabled using {code NatServerResolverImpl}.
*/
private HostnameResolver passiveNatWorkaroundStrategy = new NatServerResolverImpl(this);
/** Controls the automatic server encoding detection (only UTF-8 supported). */
private boolean autodetectEncoding;
/** Map of FEAT responses. If null, has not been initialized. */
private HashMap
* The list parsing auto-detect feature can be configured to use lenient future dates (short dates may be up to one day in the future) as follows:
*
*
* To finalize the file transfer you must call {@link #completePendingCommand completePendingCommand } and check its return value to verify success.
* If this is not done, subsequent commands may behave unexpectedly.
*
* @param remote The name of the remote file.
* @return An OutputStream through which the remote file can be appended. If the data connection cannot be opened (e.g., the file does not exist), null is
* returned (in which case you may check the reply code to determine the exact reason for failure).
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public OutputStream appendFileStream(final String remote) throws IOException {
return storeFileStream(FTPCmd.APPE, remote);
}
/**
* Change to the parent directory of the current working directory.
*
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean changeToParentDirectory() throws IOException {
return FTPReply.isPositiveCompletion(cdup());
}
/**
* Change the current working directory of the FTP session.
*
* @param pathname The new current working directory.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean changeWorkingDirectory(final String pathname) throws IOException {
return FTPReply.isPositiveCompletion(cwd(pathname));
}
/**
* There are a few FTPClient methods that do not complete the entire sequence of FTP commands to complete a transaction. These 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.
*
* For example,
*
*
* Should only be used with commands that return replies on the command channel - do not use for LIST, NLST, MLSD etc.
*
* @param command The command to invoke
* @param params The parameters string, may be {@code null}
* @return True if successfully completed, false if not, in which case call {@link #getReplyCode()} or {@link #getReplyString()} to get the reason.
*
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @since 3.0
*/
public boolean doCommand(final String command, final String params) throws IOException {
return FTPReply.isPositiveCompletion(sendCommand(command, params));
}
/**
* Issue a command and wait for the reply, returning it as an array of strings.
*
* Should only be used with commands that return replies on the command channel - do not use for LIST, NLST, MLSD etc.
*
* @param command The command to invoke
* @param params The parameters string, may be {@code null}
* @return The array of replies, or {@code null} if the command failed, in which case call {@link #getReplyCode()} or {@link #getReplyString()} to get the
* reason.
*
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @since 3.0
*/
public String[] doCommandAsStrings(final String command, final String params) throws IOException {
final boolean success = FTPReply.isPositiveCompletion(sendCommand(command, params));
if (success) {
return getReplyStrings();
}
return null;
}
/**
* Set the current data connection mode to
* N.B. currently calling any connect method will reset the mode to ACTIVE_LOCAL_DATA_CONNECTION_MODE.
*/
public void enterLocalPassiveMode() {
dataConnectionMode = PASSIVE_LOCAL_DATA_CONNECTION_MODE;
// These will be set when just before a data connection is opened
// in _openDataConnection_()
passiveHost = null;
passivePort = -1;
}
/**
* Set the current data connection mode to
* See the class Javadoc section "Control channel keep-alive feature"
*
* See the class Javadoc section "Control channel keep-alive feature"
*
* For debug use only
*
* Currently contains:
*
* Note: the timeout will also be applied when calling accept() whilst establishing an active local data connection.
*
* If the SYST command fails, and the system property {@link #FTP_SYSTEM_TYPE_DEFAULT} is defined, then this is used instead.
*
* @return The system type obtained from the server. Never null.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server (and the
* default system type property is not defined)
* @since 2.2
*/
public String getSystemType() throws IOException {
// if (syst() == FTPReply.NAME_SYSTEM_TYPE)
// Technically, we should expect a NAME_SYSTEM_TYPE response, but
// in practice FTP servers deviate, so we soften the condition to
// a positive completion.
if (systemName == null) {
if (FTPReply.isPositiveCompletion(syst())) {
// Assume that response is not empty here (cannot be null)
systemName = _replyLines.get(_replyLines.size() - 1).substring(4);
} else {
// Check if the user has provided a default for when the SYST command fails
final String systDefault = System.getProperty(FTP_SYSTEM_TYPE_DEFAULT);
if (systDefault == null) {
throw new IOException("Unable to determine system type - response: " + getReplyString());
}
systemName = systDefault;
}
}
return systemName;
}
/**
* Queries the server for a supported feature. Caches the parsed response to avoid resending the command repeatedly.
*
* @param feature the name of the feature; it is converted to upper case.
* @return {@code true} if the feature is present, {@code false} if the feature is not present or the {@link #feat()} command failed. Check
* {@link #getReplyCode()} or {@link #getReplyString()} if it is necessary to distinguish these cases.
*
* @throws IOException on error
* @since 3.8.0
*/
public boolean hasFeature(final FTPCmd feature) throws IOException {
return hasFeature(feature.name());
}
/**
* Queries the server for a supported feature. Caches the parsed response to avoid resending the command repeatedly.
*
* @param feature the name of the feature; it is converted to upper case.
* @return {@code true} if the feature is present, {@code false} if the feature is not present or the {@link #feat()} command failed. Check
* {@link #getReplyCode()} or {@link #getReplyString()} if it is necessary to distinguish these cases.
*
* @throws IOException on error
* @since 3.0
*/
public boolean hasFeature(final String feature) throws IOException {
if (!initFeatureMap()) {
return false;
}
return featuresMap.containsKey(feature.toUpperCase(Locale.ENGLISH));
}
/**
* Queries the server for a supported feature with particular value, for example "AUTH SSL" or "AUTH TLS". Caches the parsed response to avoid resending the
* command repeatedly.
*
* @param feature the name of the feature; it is converted to upper case.
* @param value the value to find.
*
* @return {@code true} if the feature is present, {@code false} if the feature is not present or the {@link #feat()} command failed. Check
* {@link #getReplyCode()} or {@link #getReplyString()} if it is necessary to distinguish these cases.
*
* @throws IOException on error
* @since 3.0
*/
public boolean hasFeature(final String feature, final String value) throws IOException {
if (!initFeatureMap()) {
return false;
}
final Set
* This method differs from using the listFiles() methods in that expensive FTPFile objects are not created until needed which may be an advantage on large
* lists.
*
* @return A FTPListParseEngine object that holds the raw information and is capable of providing parsed FTPFile objects, one for each file containing
* information contained in the given path in the format determined by the
* The server may or may not expand glob expressions. You should avoid using glob expressions because the return format for glob listings differs from
* server to server and will likely cause this method to fail.
*
* This method differs from using the listFiles() methods in that expensive FTPFile objects are not created until needed which may be an advantage on large
* lists.
*
*
* The server may or may not expand glob expressions. You should avoid using glob expressions because the return format for glob listings differs from
* server to server and will likely cause this method to fail.
*
* This method differs from using the listFiles() methods in that expensive FTPFile objects are not created until needed which may be an advantage on large
* lists.
*
* @param parserKey A string representing a designated code or fully-qualified class name of an
* This information is obtained through the LIST command. The contents of the returned array is determined by the
* N.B. the LIST command does not generally return very precise timestamps. For recent files, the response usually contains hours and minutes (not seconds).
* For older files, the output may only contain a date. If the server supports it, the MLSD command returns timestamps with a precision of seconds, and may
* include milliseconds. See {@link #mlistDir()}
*
* @return The list of directories contained in the current directory in the format determined by the autodetection mechanism.
*
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client
* being idle or some other reason causing the server to send FTP reply code 421.
* This exception may be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving
* a reply from the server.
* @throws org.apache.commons.net.ftp.parser.ParserInitializationException Thrown if the parserKey parameter cannot be resolved by the selected parser
* factory. In the DefaultFTPEntryParserFactory, this will happen when parserKey is
* neither the fully qualified class name of a class implementing the interface
* org.apache.commons.net.ftp.FTPFileEntryParser nor a string containing one of the
* recognized keys mapping to such a parser or if class loader security issues
* prevent its being loaded.
* @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.FTPFileEntryParser
* @since 3.0
*/
public FTPFile[] listDirectories() throws IOException {
return listDirectories((String) null);
}
/**
* Using the default system autodetect mechanism, obtain a list of directories contained in the specified directory.
*
* This information is obtained through the LIST command. The contents of the returned array is determined by the
* N.B. the LIST command does not generally return very precise timestamps. For recent files, the response usually contains hours and minutes (not seconds).
* For older files, the output may only contain a date. If the server supports it, the MLSD command returns timestamps with a precision of seconds, and may
* include milliseconds. See {@link #mlistDir()}
*
* @param parent the starting directory
*
* @return The list of directories contained in the specified directory in the format determined by the autodetection mechanism.
*
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client
* being idle or some other reason causing the server to send FTP reply code 421.
* This exception may be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving
* a reply from the server.
* @throws org.apache.commons.net.ftp.parser.ParserInitializationException Thrown if the parserKey parameter cannot be resolved by the selected parser
* factory. In the DefaultFTPEntryParserFactory, this will happen when parserKey is
* neither the fully qualified class name of a class implementing the interface
* org.apache.commons.net.ftp.FTPFileEntryParser nor a string containing one of the
* recognized keys mapping to such a parser or if class loader security issues
* prevent its being loaded.
* @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.FTPFileEntryParser
* @since 3.0
*/
public FTPFile[] listDirectories(final String parent) throws IOException {
return listFiles(parent, FTPFileFilters.DIRECTORIES);
}
/**
* Using the default system autodetect mechanism, obtain a list of file information for the current working directory.
*
* This information is obtained through the LIST command. The contents of the returned array is determined by the
* N.B. the LIST command does not generally return very precise timestamps. For recent files, the response usually contains hours and minutes (not seconds).
* For older files, the output may only contain a date. If the server supports it, the MLSD command returns timestamps with a precision of seconds, and may
* include milliseconds. See {@link #mlistDir()}
*
* @return The list of file information contained in the current directory in the format determined by the autodetection mechanism.
*
* NOTE: This array may contain null members if any of the individual file listings failed to parse. The caller should check each entry for
* null before referencing it.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client
* being idle or some other reason causing the server to send FTP reply code 421.
* This exception may be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving
* a reply from the server.
* @throws org.apache.commons.net.ftp.parser.ParserInitializationException Thrown if the parserKey parameter cannot be resolved by the selected parser
* factory. In the DefaultFTPEntryParserFactory, this will happen when parserKey is
* neither the fully qualified class name of a class implementing the interface
* org.apache.commons.net.ftp.FTPFileEntryParser nor a string containing one of the
* recognized keys mapping to such a parser or if class loader security issues
* prevent its being loaded.
* @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.FTPFileEntryParser
*/
public FTPFile[] listFiles() throws IOException {
return listFiles((String) null);
}
/**
* Using the default system autodetect mechanism, obtain a list of file information for the current working directory or for just a single file.
*
* This information is obtained through the LIST command. The contents of the returned array is determined by the
* N.B. the LIST command does not generally return very precise timestamps. For recent files, the response usually contains hours and minutes (not seconds).
* For older files, the output may only contain a date. If the server supports it, the MLSD command returns timestamps with a precision of seconds, and may
* include milliseconds. See {@link #mlistDir()}
*
* @param pathname The file or directory to list. Since the server may or may not expand glob expressions, using them here is not recommended and may well
* cause this method to fail. Also, some servers treat a leading '-' as being an option. To avoid this interpretation, use an absolute
* pathname or prefix the pathname with ./ (unix style servers). Some servers may support "--" as meaning end of options, in which case "--
* -xyz" should work.
*
* @return The list of file information contained in the given path in the format determined by the autodetection mechanism
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client
* being idle or some other reason causing the server to send FTP reply code 421.
* This exception may be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving
* a reply from the server.
* @throws org.apache.commons.net.ftp.parser.ParserInitializationException Thrown if the parserKey parameter cannot be resolved by the selected parser
* factory. In the DefaultFTPEntryParserFactory, this will happen when parserKey is
* neither the fully qualified class name of a class implementing the interface
* org.apache.commons.net.ftp.FTPFileEntryParser nor a string containing one of the
* recognized keys mapping to such a parser or if class loader security issues
* prevent its being loaded.
* @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.FTPFileEntryParser
*/
public FTPFile[] listFiles(final String pathname) throws IOException {
return initiateListParsing((String) null, pathname).getFiles();
}
/**
* Version of {@link #listFiles(String)} which allows a filter to be provided. For example:
* Note: if you have used {@link #setRestartOffset(long)}, the file data will start from the selected offset.
*
* @param remote The name of the remote file.
* @param local The local OutputStream to which to write the file.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some
* other reason causing the server to send FTP reply code 421. This exception may be caught either as
* an IOException or independently as itself.
* @throws org.apache.commons.net.io.CopyStreamException If an I/O error occurs while actually transferring the file. The CopyStreamException allows you to
* determine the number of bytes transferred and the IOException causing the error. This exception may
* be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the
* server.
*/
public boolean retrieveFile(final String remote, final OutputStream local) throws IOException {
return _retrieveFile(FTPCmd.RETR.getCommand(), remote, local);
}
/**
* Returns an InputStream from which a named file from the server can be read. If the current file type is ASCII, the returned InputStream will convert line
* 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.
*
* To finalize the file transfer you must call {@link #completePendingCommand completePendingCommand } and check its return value to verify success.
* If this is not done, subsequent commands may behave unexpectedly.
*
* Note: if you have used {@link #setRestartOffset(long)}, the file data will start from the selected offset.
*
* @param remote The name of the remote file.
* @return An InputStream from which the remote file can be read. If the data connection cannot be opened (e.g., the file does not exist), null is returned
* (in which case you may check the reply code to determine the exact reason for failure).
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public InputStream retrieveFileStream(final String remote) throws IOException {
return _retrieveFileStream(FTPCmd.RETR.getCommand(), remote);
}
/**
* Sends a NOOP command to the FTP server. This is useful for preventing server timeouts.
*
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean sendNoOp() throws IOException {
return FTPReply.isPositiveCompletion(noop());
}
/**
* Send a site specific command.
*
* @param arguments The site specific command and arguments.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean sendSiteCommand(final String arguments) throws IOException {
return FTPReply.isPositiveCompletion(site(arguments));
}
/**
* Set the external IP address in active mode. Useful when there are multiple network cards.
*
* @param ipAddress The external IP address of this machine.
* @throws UnknownHostException if the ipAddress cannot be resolved
* @since 2.2
*/
public void setActiveExternalIPAddress(final String ipAddress) throws UnknownHostException {
this.activeExternalHost = InetAddress.getByName(ipAddress);
}
/**
* Set the client side port range in active mode.
*
* @param minPort The lowest available port (inclusive).
* @param maxPort The highest available port (inclusive).
* @since 2.2
*/
public void setActivePortRange(final int minPort, final int maxPort) {
this.activeMinPort = minPort;
this.activeMaxPort = maxPort;
}
/**
* Enables or disables automatic server encoding detection (only UTF-8 supported).
*
* Does not affect existing connections; must be invoked before a connection is established.
*
* @param autodetect If true, automatic server encoding detection will be enabled.
*/
public void setAutodetectUTF8(final boolean autodetect) {
autodetectEncoding = autodetect;
}
/**
* Set the internal buffer size for buffered data streams.
*
* @param bufSize The size of the buffer. Use a non-positive value to use the default.
*/
public void setBufferSize(final int bufSize) {
bufferSize = bufSize;
}
/**
* Sets how long to wait for control keep-alive message replies.
*
* @param timeout number of milliseconds to wait (defaults to 1000)
* @since 3.0
* @see #setControlKeepAliveTimeout(Duration)
*/
public void setControlKeepAliveReplyTimeout(final Duration timeout) {
controlKeepAliveReplyTimeout = DurationUtils.zeroIfNull(timeout);
}
/**
* Sets how long to wait for control keep-alive message replies.
*
* @deprecated Use {@link #setControlKeepAliveReplyTimeout(Duration)}.
* @param timeoutMillis number of milliseconds to wait (defaults to 1000)
* @since 3.0
* @see #setControlKeepAliveTimeout(long)
*/
@Deprecated
public void setControlKeepAliveReplyTimeout(final int timeoutMillis) {
controlKeepAliveReplyTimeout = Duration.ofMillis(timeoutMillis);
}
/**
* Sets the time to wait between sending control connection keepalive messages when processing file upload or download.
*
* See the class Javadoc section "Control channel keep-alive feature"
*
* See the class Javadoc section "Control channel keep-alive feature"
*
* Note: the timeout will also be applied when calling accept() whilst establishing an active local data connection.
*
* @param timeout The default timeout that is used when opening a data connection socket. The value 0 (or null) means an infinite timeout.
* @since 3.9.0
*/
public void setDataTimeout(final Duration timeout) {
dataTimeout = DurationUtils.zeroIfNull(timeout);
}
/**
* Sets the timeout in milliseconds to use when reading from the data connection. This timeout will be set immediately after opening the data connection,
* provided that the value is ≥ 0.
*
* Note: the timeout will also be applied when calling accept() whilst establishing an active local data connection.
*
* N.B. currently calling any connect method will reset the type to FTP.ASCII_FILE_TYPE.
*
* @param fileType The
* N.B. currently calling any connect method will reset the type to FTP.ASCII_FILE_TYPE and the formatOrByteSize to FTP.NON_PRINT_TEXT_FORMAT.
*
* @param fileType The
* The default is true, i.e. site-local replies are replaced.
*
* The restart command is not sent to the server immediately. It is sent when a data connection is created as part of a subsequent command. The restart
* marker is reset to zero after use.
*
* Note: This method should only be invoked immediately prior to the transfer to which it applies.
*
* @param offset The offset into the remote file at which to start the next file transfer. This must be a value greater than or equal to zero.
*/
public void setRestartOffset(final long offset) {
if (offset >= 0) {
restartOffset = offset;
}
}
/**
* Sets the value to be used for the data socket SO_SNDBUF option. If the value is positive, the option will be set when the data socket has been created.
*
* @param bufSize The size of the buffer, zero or negative means the value is ignored.
* @since 3.3
*/
public void setSendDataSocketBufferSize(final int bufSize) {
sendDataSocketBufferSize = bufSize;
}
/**
* Set whether to use EPSV with IPv4. Might be worth enabling in some circumstances.
*
* For example, when using IPv4 with NAT it may work with some rare configurations. E.g. if FTP server has a static PASV address (external network) and the
* client is coming from another internal network. In that case the data connection after PASV command would fail, while EPSV would make the client succeed
* by taking just the port.
*
* @param selected value to set.
* @since 2.2
*/
public void setUseEPSVwithIPv4(final boolean selected) {
this.useEPSVwithIPv4 = selected;
}
private boolean storeFile(final FTPCmd command, final String remote, final InputStream local) throws IOException {
return _storeFile(command.getCommand(), remote, local);
}
/**
* Stores a file on the server using the given name and taking input from the given InputStream. This method does NOT close the given InputStream. If the
* current file type is ASCII, line separators in the file are transparently converted to the NETASCII format (i.e., you should not attempt to create a
* special InputStream to do this).
*
* @param remote The name to give the remote file.
* @param local The local InputStream from which to read the file.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some
* other reason causing the server to send FTP reply code 421. This exception may be caught either as
* an IOException or independently as itself.
* @throws org.apache.commons.net.io.CopyStreamException If an I/O error occurs while actually transferring the file. The CopyStreamException allows you to
* determine the number of bytes transferred and the IOException causing the error. This exception may
* be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the
* server.
*/
public boolean storeFile(final String remote, final InputStream local) throws IOException {
return storeFile(FTPCmd.STOR, remote, local);
}
private OutputStream storeFileStream(final FTPCmd command, final String remote) throws IOException {
return _storeFileStream(command.getCommand(), remote);
}
/**
* Returns an OutputStream through which data can be written to store a file on the server using the given name. If the current file type is ASCII, the
* returned OutputStream will convert line separators in the file to the NETASCII format (i.e., you should not attempt to create a 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.
*
* To finalize the file transfer you must call {@link #completePendingCommand completePendingCommand } and check its return value to verify success.
* If this is not done, subsequent commands may behave unexpectedly.
*
* @param remote The name to give the remote file.
* @return An OutputStream through which the remote file can be written. If the data connection cannot be opened (e.g., the file does not exist), null is
* returned (in which case you may check the reply code to determine the exact reason for failure).
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public OutputStream storeFileStream(final String remote) throws IOException {
return storeFileStream(FTPCmd.STOR, remote);
}
/**
* Stores a file on the server using a unique name assigned by the server and taking input from the given InputStream. This method does NOT close the given
* InputStream. If the current file type is ASCII, line separators in the file are transparently converted to the NETASCII format (i.e., you should not
* attempt to create a special InputStream to do this).
*
* @param local The local InputStream from which to read the file.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some
* other reason causing the server to send FTP reply code 421. This exception may be caught either as
* an IOException or independently as itself.
* @throws org.apache.commons.net.io.CopyStreamException If an I/O error occurs while actually transferring the file. The CopyStreamException allows you to
* determine the number of bytes transferred and the IOException causing the error. This exception may
* be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the
* server.
*/
public boolean storeUniqueFile(final InputStream local) throws IOException {
return storeFile(FTPCmd.STOU, null, local);
}
/**
* Stores a file on the server using a unique name derived from the given name and taking input from the given InputStream. This method does NOT close the
* given InputStream. If the current file type is ASCII, line separators in the file are transparently converted to the NETASCII format (i.e., you should
* not attempt to create a special InputStream to do this).
*
* @param remote The name on which to base the unique name given to the remote file.
* @param local The local InputStream from which to read the file.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some
* other reason causing the server to send FTP reply code 421. This exception may be caught either as
* an IOException or independently as itself.
* @throws org.apache.commons.net.io.CopyStreamException If an I/O error occurs while actually transferring the file. The CopyStreamException allows you to
* determine the number of bytes transferred and the IOException causing the error. This exception may
* be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the
* server.
*/
public boolean storeUniqueFile(final String remote, final InputStream local) throws IOException {
return storeFile(FTPCmd.STOU, remote, local);
}
/**
* Returns an OutputStream through which data can be written to store a file on the server using a unique name assigned by the server. If the current file
* type is ASCII, the returned OutputStream will convert line separators in the file to the NETASCII format (i.e., you should not attempt to create a
* 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.
*
* To finalize the file transfer you must call {@link #completePendingCommand completePendingCommand } and check its return value to verify success.
* If this is not done, subsequent commands may behave unexpectedly.
*
* @return An OutputStream through which the remote file can be written. If the data connection cannot be opened (e.g., the file does not exist), null is
* returned (in which case you may check the reply code to determine the exact reason for failure).
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public OutputStream storeUniqueFileStream() throws IOException {
return storeFileStream(FTPCmd.STOU, null);
}
/**
* Returns an OutputStream through which data can be written to store a file on the server using a unique name derived from the given name. If the current
* file type is ASCII, the returned OutputStream will convert line separators in the file to the NETASCII format (i.e., you should not attempt to create a
* 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.
*
* To finalize the file transfer you must call {@link #completePendingCommand completePendingCommand } and check its return value to verify success.
* If this is not done, subsequent commands may behave unexpectedly.
*
* @param remote The name on which to base the unique name given to the remote file.
* @return An OutputStream through which the remote file can be written. If the data connection cannot be opened (e.g., the file does not exist), null is
* returned (in which case you may check the reply code to determine the exact reason for failure).
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public OutputStream storeUniqueFileStream(final String remote) throws IOException {
return storeFileStream(FTPCmd.STOU, remote);
}
/**
* Issue the FTP SMNT command.
*
* @param pathname The pathname to mount.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean structureMount(final String pathname) throws IOException {
return FTPReply.isPositiveCompletion(smnt(pathname));
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPClientConfig.java 0000664 0000000 0000000 00000066647 14340477222 0032306 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.text.DateFormatSymbols;
import java.util.Collection;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;
/**
*
* This class implements an alternate means of configuring the {@link org.apache.commons.net.ftp.FTPClient FTPClient} object and also subordinate objects which
* it uses. Any class implementing the {@link org.apache.commons.net.ftp.Configurable Configurable } interface can be configured by this object.
*
* In particular this class was designed primarily to support configuration of FTP servers which express file timestamps in formats and languages other than
* those for the US locale, which although it is the most common is not universal. Unfortunately, nothing in the FTP spec allows this to be determined in an
* automated way, so manual configuration such as this is necessary.
*
* This functionality was designed to allow existing clients to work exactly as before without requiring use of this component. This component should only need
* to be explicitly invoked by the user of this package for problem cases that previous implementations could not solve.
*
* Unpaged (whole list) access on a UNIX server that uses French month names but uses the "standard"
* Paged access on a UNIX server that uses Danish month names and "European" date formatting in Denmark's time zone, when you are in some other time zone.
*
*
* Unpaged (whole list) access on a VMS server that uses month names in a language not {@link #getSupportedLanguageCodes() supported} by the system. but uses
* the "standard"
* Unpaged (whole list) access on a Windows-NT server in a different time zone. (Note, since the NT Format uses numeric date formatting, language issues are
* irrelevant here).
*
*
* getter for the {@link #setServerLanguageCode(String) serverLanguageCode} property.
*
* getter for the {@link #setShortMonthNames(String) shortMonthNames} property.
*
* If true, the FTPFile for any unparseable entries will contain only the unparsed entry {@link FTPFile#getRawListing()} and
* {@link FTPFile#isValid()} will return {@code false}
* @since 3.4
*/
public boolean getUnparseableEntries() {
return this.saveUnparseableEntries;
}
/**
*
* getter for the {@link #setLenientFutureDates(boolean) lenientFutureDates} property.
*
* setter for the defaultDateFormatStr property. This property specifies the main date format that will be used by a parser configured by this configuration
* to parse file timestamps. If this is not specified, such a parser will use as a default value, the most commonly used format which will be in as used in
*
* This should be in the format described for
* setter for the lenientFutureDates property. This boolean property (default: true) only has meaning when a {@link #setRecentDateFormatStr(String)
* recentDateFormatStr} property has been set. In that case, if this property is set true, then the parser, when it encounters a listing parseable with the
* recent date format, will only consider a date to belong to the previous year if it is more than one day in the future. This will allow all out-of-synch
* situations (whether based on "slop" - i.e. servers simply out of synch with one another or because of time zone differences - but in the latter case it
* is highly recommended to use the {@link #setServerTimeZoneId(String) serverTimeZoneId} property instead) to resolve correctly.
*
* This is used primarily in unix-based systems.
*
* setter for the recentDateFormatStr property. This property specifies a secondary date format that will be used by a parser configured by this
* configuration to parse file timestamps, typically those less than a year old. If this is not specified, such a parser will not attempt to parse using an
* alternate format.
*
* This is used primarily in unix-based systems.
*
* This should be in the format described for
* setter for the serverLanguageCode property. This property allows user to specify a
* two-letter ISO-639 language code that will be used to configure the set of month names used by the file timestamp parser. If neither this nor the
* {@link #setShortMonthNames(String) shortMonthNames} is specified, parsing will assume English month names, which may or may not be significant, depending
* on whether the date format(s) specified via {@link #setDefaultDateFormatStr(String) defaultDateFormatStr} and/or {@link #setRecentDateFormatStr(String)
* recentDateFormatStr} are using numeric or alphabetic month names.
*
* If the code supplied is not supported here,
* Please note that this attribute will NOT be used to determine a locale-based date format for the language. Experience has shown that
* many if not most FTP servers outside the United States employ the standard
* setter for the serverTimeZoneId property. This property allows a time zone to be specified corresponding to that known to be used by an FTP server in
* file listings. This might be particularly useful to clients such as Ant that try to use these timestamps for dependency checking.
*
* This should be one of the identifiers used by
* setter for the shortMonthNames property. This property allows the user to specify a set of month names used by the server that is different from those
* that may be specified using the {@link #setServerLanguageCode(String) serverLanguageCode} property.
*
* This should be a string containing twelve strings each composed of three characters, delimited by pipe (|) characters. Currently, only 8-bit ASCII
* characters are known to be supported. For example, a set of month names used by a hypothetical Icelandic FTP server might conceivably be specified as
*
* In this case, the FTPFile will contain only the unparsed entry {@link FTPFile#getRawListing()} and {@link FTPFile#isValid()} will return {@code false}
*
* @param saveUnparseable if true, then create FTPFile entries if parsing fails
* @since 3.4
*/
public void setUnparseableEntries(final boolean saveUnparseable) {
this.saveUnparseableEntries = saveUnparseable;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPCmd.java 0000664 0000000 0000000 00000006164 14340477222 0030431 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
/**
* @since 3.3
*/
public enum FTPCmd {
ABOR, ACCT, ALLO, APPE, CDUP, CWD, DELE, EPRT, EPSV, FEAT, HELP, LIST, MDTM, MFMT, MKD, MLSD, MLST, MODE, NLST, NOOP, PASS, PASV, PORT, PWD, QUIT, REIN,
REST, RETR, RMD, RNFR, RNTO, SITE,
/** @since 3.7 */
SIZE, SMNT, STAT, STOR, STOU, STRU, SYST, TYPE, USER,;
// Aliases
public static final FTPCmd ABORT = ABOR;
public static final FTPCmd ACCOUNT = ACCT;
public static final FTPCmd ALLOCATE = ALLO;
public static final FTPCmd APPEND = APPE;
public static final FTPCmd CHANGE_TO_PARENT_DIRECTORY = CDUP;
public static final FTPCmd CHANGE_WORKING_DIRECTORY = CWD;
public static final FTPCmd DATA_PORT = PORT;
public static final FTPCmd DELETE = DELE;
public static final FTPCmd FEATURES = FEAT;
public static final FTPCmd FILE_STRUCTURE = STRU;
public static final FTPCmd GET_MOD_TIME = MDTM;
public static final FTPCmd LOGOUT = QUIT;
public static final FTPCmd MAKE_DIRECTORY = MKD;
public static final FTPCmd MOD_TIME = MDTM;
public static final FTPCmd NAME_LIST = NLST;
public static final FTPCmd PASSIVE = PASV;
public static final FTPCmd PASSWORD = PASS;
public static final FTPCmd PRINT_WORKING_DIRECTORY = PWD;
public static final FTPCmd REINITIALIZE = REIN;
public static final FTPCmd REMOVE_DIRECTORY = RMD;
public static final FTPCmd RENAME_FROM = RNFR;
public static final FTPCmd RENAME_TO = RNTO;
public static final FTPCmd REPRESENTATION_TYPE = TYPE;
public static final FTPCmd RESTART = REST;
public static final FTPCmd RETRIEVE = RETR;
public static final FTPCmd SET_MOD_TIME = MFMT;
public static final FTPCmd SITE_PARAMETERS = SITE;
public static final FTPCmd STATUS = STAT;
public static final FTPCmd STORE = STOR;
public static final FTPCmd STORE_UNIQUE = STOU;
public static final FTPCmd STRUCTURE_MOUNT = SMNT;
public static final FTPCmd SYSTEM = SYST;
public static final FTPCmd TRANSFER_MODE = MODE;
public static final FTPCmd USERNAME = USER;
/**
* Retrieve the FTP protocol command string corresponding to a specified command code.
*
* @return The FTP protcol command string corresponding to a specified command code.
*/
public final String getCommand() {
return this.name();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPCommand.java 0000664 0000000 0000000 00000014161 14340477222 0031300 0 ustar 00root root 0000000 0000000 /*
* 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.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.
*
* @deprecated use {@link FTPCmd} instead
*/
@Deprecated
public final class FTPCommand {
public static final int USER = 0;
public static final int PASS = 1;
public static final int ACCT = 2;
public static final int CWD = 3;
public static final int CDUP = 4;
public static final int SMNT = 5;
public static final int REIN = 6;
public static final int QUIT = 7;
public static final int PORT = 8;
public static final int PASV = 9;
public static final int TYPE = 10;
public static final int STRU = 11;
public static final int MODE = 12;
public static final int RETR = 13;
public static final int STOR = 14;
public static final int STOU = 15;
public static final int APPE = 16;
public static final int ALLO = 17;
public static final int REST = 18;
public static final int RNFR = 19;
public static final int RNTO = 20;
public static final int ABOR = 21;
public static final int DELE = 22;
public static final int RMD = 23;
public static final int MKD = 24;
public static final int PWD = 25;
public static final int LIST = 26;
public static final int NLST = 27;
public static final int SITE = 28;
public static final int SYST = 29;
public static final int STAT = 30;
public static final int HELP = 31;
public static final int NOOP = 32;
/** @since 2.0 */
public static final int MDTM = 33;
/** @since 2.2 */
public static final int FEAT = 34;
/** @since 2.2 */
public static final int MFMT = 35;
/** @since 2.2 */
public static final int EPSV = 36;
/** @since 2.2 */
public static final int EPRT = 37;
/**
* Machine parseable list for a directory
*
* @since 3.0
*/
public static final int MLSD = 38;
/**
* Machine parseable list for a single file
*
* @since 3.0
*/
public static final int MLST = 39;
// Must agree with final entry above; used to check array size
private static final int LAST = MLST;
public static final int USERNAME = USER;
public static final int PASSWORD = PASS;
public static final int ACCOUNT = ACCT;
public static final int CHANGE_WORKING_DIRECTORY = CWD;
public static final int CHANGE_TO_PARENT_DIRECTORY = CDUP;
public static final int STRUCTURE_MOUNT = SMNT;
public static final int REINITIALIZE = REIN;
public static final int LOGOUT = QUIT;
public static final int DATA_PORT = PORT;
public static final int PASSIVE = PASV;
public static final int REPRESENTATION_TYPE = TYPE;
public static final int FILE_STRUCTURE = STRU;
public static final int TRANSFER_MODE = MODE;
public static final int RETRIEVE = RETR;
public static final int STORE = STOR;
public static final int STORE_UNIQUE = STOU;
public static final int APPEND = APPE;
public static final int ALLOCATE = ALLO;
public static final int RESTART = REST;
public static final int RENAME_FROM = RNFR;
public static final int RENAME_TO = RNTO;
public static final int ABORT = ABOR;
public static final int DELETE = DELE;
public static final int REMOVE_DIRECTORY = RMD;
public static final int MAKE_DIRECTORY = MKD;
public static final int PRINT_WORKING_DIRECTORY = PWD;
// public static final int LIST = LIST;
public static final int NAME_LIST = NLST;
public static final int SITE_PARAMETERS = SITE;
public static final int SYSTEM = SYST;
public static final int STATUS = STAT;
// public static final int HELP = HELP;
// public static final int NOOP = NOOP;
/** @since 2.0 */
public static final int MOD_TIME = MDTM;
/** @since 2.2 */
public static final int FEATURES = FEAT;
/** @since 2.2 */
public static final int GET_MOD_TIME = MDTM;
/** @since 2.2 */
public static final int SET_MOD_TIME = MFMT;
private static final String[] COMMANDS = { "USER", "PASS", "ACCT", "CWD", "CDUP", "SMNT", "REIN", "QUIT", "PORT", "PASV", "TYPE", "STRU", "MODE", "RETR",
"STOR", "STOU", "APPE", "ALLO", "REST", "RNFR", "RNTO", "ABOR", "DELE", "RMD", "MKD", "PWD", "LIST", "NLST", "SITE", "SYST", "STAT", "HELP", "NOOP",
"MDTM", "FEAT", "MFMT", "EPSV", "EPRT", "MLSD", "MLST" };
// default access needed for Unit test
static void checkArray() {
final int expectedLength = LAST + 1;
if (COMMANDS.length != expectedLength) {
throw new RuntimeException("Incorrect _commands array. Should have length " + expectedLength + " found " + COMMANDS.length);
}
}
/**
* Retrieve the FTP protocol command string corresponding to a specified command code.
*
* @param command The command code.
* @return The FTP protcol command string corresponding to a specified command code.
*/
public static String getCommand(final int command) {
return COMMANDS[command];
}
// Cannot be instantiated
private FTPCommand() {
}
}
FTPConnectionClosedException.java 0000664 0000000 0000000 00000003520 14340477222 0034750 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp /*
* 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.ftp;
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
* exception is derived from IOException and therefore may be caught either as an IOException or specifically as an FTPConnectionClosedException.
*
* @see FTP
* @see FTPClient
*/
public class FTPConnectionClosedException extends IOException {
private static final long serialVersionUID = 3500547241659379952L;
/** Constructs a FTPConnectionClosedException with no message */
public FTPConnectionClosedException() {
}
/**
* Constructs a FTPConnectionClosedException with a specified message.
*
* @param message The message explaining the reason for the exception.
*/
public FTPConnectionClosedException(final String message) {
super(message);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPFile.java 0000664 0000000 0000000 00000037153 14340477222 0030607 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.io.Serializable;
import java.time.Instant;
import java.util.Calendar;
import java.util.Date;
import java.util.Formatter;
import java.util.TimeZone;
/**
* The FTPFile class is used to represent information about files stored on an FTP server.
*
* @see FTPFileEntryParser
* @see FTPClient#listFiles
*/
public class FTPFile implements Serializable {
private static final long serialVersionUID = 9010790363003271996L;
/** A constant indicating an FTPFile is a file. */
public static final int FILE_TYPE = 0;
/** A constant indicating an FTPFile is a directory. */
public static final int DIRECTORY_TYPE = 1;
/** A constant indicating an FTPFile is a symbolic link. */
public static final int SYMBOLIC_LINK_TYPE = 2;
/** A constant indicating an FTPFile is of unknown type. */
public static final int UNKNOWN_TYPE = 3;
/** A constant indicating user access permissions. */
public static final int USER_ACCESS = 0;
/** A constant indicating group access permissions. */
public static final int GROUP_ACCESS = 1;
/** A constant indicating world access permissions. */
public static final int WORLD_ACCESS = 2;
/** A constant indicating file/directory read permission. */
public static final int READ_PERMISSION = 0;
/** A constant indicating file/directory write permission. */
public static final int WRITE_PERMISSION = 1;
/**
* A constant indicating file execute permission or directory listing permission.
*/
public static final int EXECUTE_PERMISSION = 2;
private int type = UNKNOWN_TYPE;
/** 0 is invalid as a link count. */
private int hardLinkCount;
/** 0 is valid, so use -1. */
private long size = -1;
private String rawListing;
private String user = "";
private String group = "";
private String name;
private String link;
// TODO Consider changing internal representation to java.time.
private Calendar calendar;
/** If this is null, then list entry parsing failed. */
private final boolean[][] permissions; // e.g. _permissions[USER_ACCESS][READ_PERMISSION]
/** Creates an empty FTPFile. */
public FTPFile() {
permissions = new boolean[3][3];
}
/**
* Constructor for use by {@link FTPListParseEngine} only. Used to create FTPFile entries for failed parses
*
* @param rawListing line that could not be parsed.
* @since 3.4
*/
FTPFile(final String rawListing) {
this.permissions = null; // flag that entry is invalid
this.rawListing = rawListing;
}
private char formatType() {
switch (type) {
case FILE_TYPE:
return '-';
case DIRECTORY_TYPE:
return 'd';
case SYMBOLIC_LINK_TYPE:
return 'l';
default:
return '?';
}
}
/**
* Gets the name of the group owning the file. Sometimes this will be a string representation of the group number.
*
* @return The name of the group owning the file.
*/
public String getGroup() {
return group;
}
/**
* Gets the number of hard links to this file. This is not to be confused with symbolic links.
*
* @return The number of hard links to this file.
*/
public int getHardLinkCount() {
return hardLinkCount;
}
/**
* If the FTPFile is a symbolic link, this method returns the name of the file being pointed to by the symbolic link. Otherwise it returns null.
*
* @return The file pointed to by the symbolic link (null if the FTPFile is not a symbolic link).
*/
public String getLink() {
return link;
}
/**
* Gets the name of the file.
*
* @return The name of the file.
*/
public String getName() {
return name;
}
/**
* Gets the original FTP server raw listing used to initialize the FTPFile.
*
* @return The original FTP server raw listing used to initialize the FTPFile.
*/
public String getRawListing() {
return rawListing;
}
/**
* Gets the file size in bytes.
*
* @return The file size in bytes.
*/
public long getSize() {
return size;
}
/**
* Gets the file timestamp. This usually the last modification time.
*
* @return A Calendar instance representing the file timestamp.
*/
public Calendar getTimestamp() {
return calendar;
}
/**
* Gets the file timestamp. This usually the last modification time.
*
* @return A Calendar instance representing the file timestamp.
* @since 3.9.0
*/
public Instant getTimestampInstant() {
return calendar == null ? null : calendar.toInstant();
}
/**
* Gets the type of the file (one of the
* Note: if the instance is not valid {@link #isValid()}, no useful information can be returned. In this case, use {@link #getRawListing()} instead.
*
* Note: if the instance is not valid {@link #isValid()}, no useful information can be returned. In this case, use {@link #getRawListing()} instead.
*
* Here are some examples showing how to use one of the classes that implement this interface.
*
*
* The first example uses the
* This object defines a two-part parsing mechanism.
*
* The first part is comprised of reading the raw input into an internal list of strings. Every item in this list corresponds to an actual file. All extraneous
* matter emitted by the server will have been removed by the end of this phase. This is accomplished in conjunction with the FTPFileEntryParser associated with
* this engine, by calling its methods
* The second part is composed of the actual parsing, again in conjunction with the particular parser used by this engine. This is controlled by an iterator
* over the internal list of strings. This may be done either in block mode, by calling the
* Examples:
*
* Paged access:
*
*
* For unpaged access, simply use FTPClient.listFiles(). That method uses this class transparently.
*/
public class FTPListParseEngine {
/**
* An empty immutable {@code FTPFile} array.
*/
private static final FTPFile[] EMPTY_FTP_FILE_ARRAY = {};
private List
* NOTE: This array may contain null members if any of the individual file listings failed to parse. The caller should check each entry for
* null before referencing it, or use the a filter such as {@link FTPFileFilters#NON_NULL} which does not allow null entries.
* @since 3.9.0
*/
public List
* NOTE: This array may contain null members if any of the individual file listings failed to parse. The caller should check each entry for
* null before referencing it, or use the a filter such as {@link FTPFileFilters#NON_NULL} which does not allow null entries.
* @since 2.2
* @throws IOException - not ever thrown, may be removed in a later release
*/
public FTPFile[] getFiles(final FTPFileFilter filter) throws IOException // TODO remove; not actually thrown
{
return getFileList(filter).toArray(EMPTY_FTP_FILE_ARRAY);
}
/**
* Returns an array of at most
* NOTE: This array may contain null members if any of the individual file listings failed to parse. The caller should check each entry for
* null before referencing it.
*/
public FTPFile[] getNext(final int quantityRequested) {
final List
* NOTE: This array may contain null members if any of the individual file listings failed to parse. The caller should check each entry for
* null before referencing it.
*/
public FTPFile[] getPrevious(final int quantityRequested) {
final List
* TODO replace with an enum
*/
public final class FTPReply {
public static final int RESTART_MARKER = 110;
public static final int SERVICE_NOT_READY = 120;
public static final int DATA_CONNECTION_ALREADY_OPEN = 125;
public static final int FILE_STATUS_OK = 150;
public static final int COMMAND_OK = 200;
public static final int COMMAND_IS_SUPERFLUOUS = 202;
public static final int SYSTEM_STATUS = 211;
public static final int DIRECTORY_STATUS = 212;
public static final int FILE_STATUS = 213;
public static final int HELP_MESSAGE = 214;
public static final int NAME_SYSTEM_TYPE = 215;
public static final int SERVICE_READY = 220;
public static final int SERVICE_CLOSING_CONTROL_CONNECTION = 221;
public static final int DATA_CONNECTION_OPEN = 225;
public static final int CLOSING_DATA_CONNECTION = 226;
public static final int ENTERING_PASSIVE_MODE = 227;
/** @since 2.2 */
public static final int ENTERING_EPSV_MODE = 229;
public static final int USER_LOGGED_IN = 230;
public static final int FILE_ACTION_OK = 250;
public static final int PATHNAME_CREATED = 257;
public static final int NEED_PASSWORD = 331;
public static final int NEED_ACCOUNT = 332;
public static final int FILE_ACTION_PENDING = 350;
public static final int SERVICE_NOT_AVAILABLE = 421;
public static final int CANNOT_OPEN_DATA_CONNECTION = 425;
public static final int TRANSFER_ABORTED = 426;
public static final int FILE_ACTION_NOT_TAKEN = 450;
public static final int ACTION_ABORTED = 451;
public static final int INSUFFICIENT_STORAGE = 452;
public static final int UNRECOGNIZED_COMMAND = 500;
public static final int SYNTAX_ERROR_IN_ARGUMENTS = 501;
public static final int COMMAND_NOT_IMPLEMENTED = 502;
public static final int BAD_COMMAND_SEQUENCE = 503;
public static final int COMMAND_NOT_IMPLEMENTED_FOR_PARAMETER = 504;
public static final int NOT_LOGGED_IN = 530;
public static final int NEED_ACCOUNT_FOR_STORING_FILES = 532;
public static final int FILE_UNAVAILABLE = 550;
public static final int PAGE_TYPE_UNKNOWN = 551;
public static final int STORAGE_ALLOCATION_EXCEEDED = 552;
public static final int FILE_NAME_NOT_ALLOWED = 553;
// FTPS Reply Codes
/** @since 2.0 */
public static final int SECURITY_DATA_EXCHANGE_COMPLETE = 234;
/** @since 2.0 */
public static final int SECURITY_DATA_EXCHANGE_SUCCESSFULLY = 235;
/** @since 2.0 */
public static final int SECURITY_MECHANISM_IS_OK = 334;
/** @since 2.0 */
public static final int SECURITY_DATA_IS_ACCEPTABLE = 335;
/** @since 2.0 */
public static final int UNAVAILABLE_RESOURCE = 431;
/** @since 2.2 */
public static final int BAD_TLS_NEGOTIATION_OR_DATA_ENCRYPTION_REQUIRED = 522;
/** @since 2.0 */
public static final int DENIED_FOR_POLICY_REASONS = 533;
/** @since 2.0 */
public static final int REQUEST_DENIED = 534;
/** @since 2.0 */
public static final int FAILED_SECURITY_CHECK = 535;
/** @since 2.0 */
public static final int REQUESTED_PROT_LEVEL_NOT_SUPPORTED = 536;
// IPv6 error codes
// Note this is also used as an FTPS error code reply
/** @since 2.2 */
public static final int EXTENDED_PORT_FAILURE = 522;
/**
* Determine if a reply code is a negative permanent response. All codes beginning with a 5 are negative permanent responses. The FTP server will send a
* negative permanent response on the failure of a command that cannot be reattempted with success.
*
* @param reply The reply code to test.
* @return True if a reply code is a negative permanent response, false if not.
*/
public static boolean isNegativePermanent(final int reply) {
return reply >= 500 && reply < 600;
}
/**
* Determine if a reply code is a negative transient response. All codes beginning with a 4 are negative transient responses. The FTP server will send a
* negative transient response on the failure of a command that can be reattempted with success.
*
* @param reply The reply code to test.
* @return True if a reply code is a negative transient response, false if not.
*/
public static boolean isNegativeTransient(final int reply) {
return reply >= 400 && reply < 500;
}
/**
* Determine if a reply code is a positive completion response. All codes beginning with a 2 are positive completion responses. The FTP server will send a
* positive completion response on the final successful completion of a command.
*
* @param reply The reply code to test.
* @return True if a reply code is a positive completion response, false if not.
*/
public static boolean isPositiveCompletion(final int reply) {
return reply >= 200 && reply < 300;
}
/**
* Determine if a reply code is a positive intermediate response. All codes beginning with a 3 are positive intermediate responses. The FTP server will send
* a positive intermediate response on the successful completion of one part of a multi-part sequence of commands. For example, after a successful USER
* command, a positive intermediate response will be sent to indicate that the server is ready for the PASS command.
*
* @param reply The reply code to test.
* @return True if a reply code is a positive intermediate response, false if not.
*/
public static boolean isPositiveIntermediate(final int reply) {
return reply >= 300 && reply < 400;
}
/**
* Determine if a reply code is a positive preliminary response. All codes beginning with a 1 are positive preliminary responses. Postitive preliminary
* responses are used to indicate tentative success. No further commands can be issued to the FTP server after a positive preliminary response until a
* follow up response is received from the server.
*
* @param reply The reply code to test.
* @return True if a reply code is a positive preliminary response, false if not.
*/
public static boolean isPositivePreliminary(final int reply) {
return reply >= 100 && reply < 200;
}
/**
* Determine if a reply code is a protected response.
*
* @param reply The reply code to test.
* @return True if a reply code is a protected response, false if not.
* @since 3.0
*/
public static boolean isProtectedReplyCode(final int reply) {
// actually, only 3 protected reply codes are
// defined in RFC 2228: 631, 632 and 633.
return reply >= 600 && reply < 700;
}
// Cannot be instantiated
private FTPReply() {
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPSClient.java 0000664 0000000 0000000 00000117324 14340477222 0031270 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import org.apache.commons.net.util.Base64;
import org.apache.commons.net.util.SSLContextUtils;
import org.apache.commons.net.util.SSLSocketUtils;
import org.apache.commons.net.util.TrustManagerUtils;
/**
* FTP over SSL processing. If desired, the JVM property -Djavax.net.debug=all can be used to see wire-level SSL details.
*
* Warning: the hostname is not verified against the certificate by default, use {@link #setHostnameVerifier(HostnameVerifier)} or
* {@link #setEndpointCheckingEnabled(boolean)} (on Java 1.7+) to enable verification. Verification is only performed on client mode connections.
*
* @since 2.0
*/
public class FTPSClient extends FTPClient {
// From http://www.iana.org/assignments/port-numbers
// ftps-data 989/tcp ftp protocol, data, over TLS/SSL
// ftps-data 989/udp ftp protocol, data, over TLS/SSL
// ftps 990/tcp ftp protocol, control, over TLS/SSL
// ftps 990/udp ftp protocol, control, over TLS/SSL
public static final int DEFAULT_FTPS_DATA_PORT = 989;
public static final int DEFAULT_FTPS_PORT = 990;
/** The value that I can set in PROT command (C = Clear, P = Protected) */
private static final String[] PROT_COMMAND_VALUE = { "C", "E", "S", "P" };
/** Default PROT Command */
private static final String DEFAULT_PROT = "C";
/** Default secure socket protocol name, i.e. TLS */
private static final String DEFAULT_PROTOCOL = "TLS";
/** The AUTH (Authentication/Security Mechanism) command. */
private static final String CMD_AUTH = "AUTH";
/** The ADAT (Authentication/Security Data) command. */
private static final String CMD_ADAT = "ADAT";
/** The PROT (Data Channel Protection Level) command. */
private static final String CMD_PROT = "PROT";
/** The PBSZ (Protection Buffer Size) command. */
private static final String CMD_PBSZ = "PBSZ";
/** The MIC (Integrity Protected Command) command. */
private static final String CMD_MIC = "MIC";
/** The CONF (Confidentiality Protected Command) command. */
private static final String CMD_CONF = "CONF";
/** The ENC (Privacy Protected Command) command. */
private static final String CMD_ENC = "ENC";
/** The CCC (Clear Command Channel) command. */
private static final String CMD_CCC = "CCC";
/** @deprecated - not used - may be removed in a future release */
@Deprecated
public static String KEYSTORE_ALGORITHM;
/** @deprecated - not used - may be removed in a future release */
@Deprecated
public static String TRUSTSTORE_ALGORITHM;
/** @deprecated - not used - may be removed in a future release */
@Deprecated
public static String PROVIDER;
/** @deprecated - not used - may be removed in a future release */
@Deprecated
public static String STORE_TYPE;
/** The security mode. (True - Implicit Mode / False - Explicit Mode) */
private final boolean isImplicit;
/** The secure socket protocol to be used, e.g. SSL/TLS. */
private final String protocol;
/** The AUTH Command value */
private String auth = DEFAULT_PROTOCOL;
/** The context object. */
private SSLContext context;
/** The socket object. */
private Socket plainSocket;
/** Controls whether a new SSL session may be established by this socket. Default true. */
private boolean isCreation = true;
/** The use client mode flag. */
private boolean isClientMode = true;
/** The need client auth flag. */
private boolean isNeedClientAuth;
/** The want client auth flag. */
private boolean isWantClientAuth;
/** The cipher suites */
private String[] suites;
/** The protocol versions */
private String[] protocols;
/**
* The FTPS {@link TrustManager} implementation, default validate only {@link TrustManagerUtils#getValidateServerCertificateTrustManager()}.
*/
private TrustManager trustManager = TrustManagerUtils.getValidateServerCertificateTrustManager();
/** The {@link KeyManager}, default null (i.e. use system default). */
private KeyManager keyManager;
/** The {@link HostnameVerifier} to use post-TLS, default null (i.e. no verification). */
private HostnameVerifier hostnameVerifier;
/** Use Java 1.7+ HTTPS Endpoint Identification Algorithm. */
private boolean tlsEndpointChecking;
/**
* Constructor for FTPSClient, calls {@link #FTPSClient(String, boolean)}.
*
* Sets protocol to {@link #DEFAULT_PROTOCOL} - i.e. TLS - and security mode to explicit (isImplicit = false)
*/
public FTPSClient() {
this(DEFAULT_PROTOCOL, false);
}
/**
* Constructor for FTPSClient, using {@link #DEFAULT_PROTOCOL} - i.e. TLS Calls {@link #FTPSClient(String, boolean)}
*
* @param isImplicit The security mode (Implicit/Explicit).
*/
public FTPSClient(final boolean isImplicit) {
this(DEFAULT_PROTOCOL, isImplicit);
}
/**
* Constructor for FTPSClient, using {@link #DEFAULT_PROTOCOL} - i.e. TLS The default TrustManager is set from
* {@link TrustManagerUtils#getValidateServerCertificateTrustManager()}
*
* @param isImplicit The security mode(Implicit/Explicit).
* @param context A pre-configured SSL Context
*/
public FTPSClient(final boolean isImplicit, final SSLContext context) {
this(DEFAULT_PROTOCOL, isImplicit);
this.context = context;
}
/**
* Constructor for FTPSClient, using {@link #DEFAULT_PROTOCOL} - i.e. TLS and isImplicit {@code false} Calls {@link #FTPSClient(boolean, SSLContext)}
*
* @param context A pre-configured SSL Context
*/
public FTPSClient(final SSLContext context) {
this(false, context);
}
/**
* Constructor for FTPSClient, using explict mode, calls {@link #FTPSClient(String, boolean)}.
*
* @param protocol the protocol to use
*/
public FTPSClient(final String protocol) {
this(protocol, false);
}
/**
* Constructor for FTPSClient allowing specification of protocol and security mode. If isImplicit is true, the port is set to {@link #DEFAULT_FTPS_PORT}
* i.e. 990. The default TrustManager is set from {@link TrustManagerUtils#getValidateServerCertificateTrustManager()}
*
* @param protocol the protocol
* @param isImplicit The security mode(Implicit/Explicit).
*/
public FTPSClient(final String protocol, final boolean isImplicit) {
this.protocol = protocol;
this.isImplicit = isImplicit;
if (isImplicit) {
setDefaultPort(DEFAULT_FTPS_PORT);
}
}
/**
* Because there are so many connect() methods, the _connectAction_() method is provided as a means of performing some action immediately after establishing
* a connection, rather than reimplementing all of the connect() methods.
*
* @throws IOException If it throw by _connectAction_.
* @see org.apache.commons.net.SocketClient#_connectAction_()
*/
@Override
protected void _connectAction_() throws IOException {
// Implicit mode.
if (isImplicit) {
applySocketAttributes();
sslNegotiation();
}
super._connectAction_();
// Explicit mode.
if (!isImplicit) {
execAUTH();
sslNegotiation();
}
}
/**
* Returns a socket of the data connection. Wrapped as an {@link SSLSocket}, which carries out handshake processing.
*
* @param command The int representation of the FTP command to send.
* @param arg The arguments to the FTP command. If this parameter is set to null, then the command is sent with no arguments.
* @return corresponding to the established data connection. Null is returned if an FTP protocol error is reported at any point during the establishment and
* initialization of the connection.
* @throws IOException If there is any problem with the connection.
* @see FTPClient#_openDataConnection_(int, String)
* @deprecated (3.3) Use {@link FTPClient#_openDataConnection_(FTPCmd, String)} instead
*/
@Override
// Strictly speaking this is not needed, but it works round a Clirr bug
// So rather than invoke the parent code, we do it here
@Deprecated
protected Socket _openDataConnection_(final int command, final String arg) throws IOException {
return _openDataConnection_(FTPCommand.getCommand(command), arg);
}
/**
* Returns a socket of the data connection. Wrapped as an {@link SSLSocket}, which carries out handshake processing.
*
* @param command The textual representation of the FTP command to send.
* @param arg The arguments to the FTP command. If this parameter is set to null, then the command is sent with no arguments.
* @return corresponding to the established data connection. Null is returned if an FTP protocol error is reported at any point during the establishment and
* initialization of the connection.
* @throws IOException If there is any problem with the connection.
* @see FTPClient#_openDataConnection_(int, String)
* @since 3.2
*/
@Override
protected Socket _openDataConnection_(final String command, final String arg) throws IOException {
final Socket socket = openDataSecureConnection(command, arg);
_prepareDataSocket_(socket);
if (socket instanceof SSLSocket) {
final SSLSocket sslSocket = (SSLSocket) socket;
sslSocket.setUseClientMode(isClientMode);
sslSocket.setEnableSessionCreation(isCreation);
// server mode
if (!isClientMode) {
sslSocket.setNeedClientAuth(isNeedClientAuth);
sslSocket.setWantClientAuth(isWantClientAuth);
}
if (suites != null) {
sslSocket.setEnabledCipherSuites(suites);
}
if (protocols != null) {
sslSocket.setEnabledProtocols(protocols);
}
sslSocket.startHandshake();
}
return socket;
}
/**
* Performs any custom initialization for a newly created SSLSocket (before the SSL handshake happens). Called by {@link #_openDataConnection_(int, String)}
* immediately after creating the socket. The default implementation is a no-op
*
* @param socket the socket to set up
* @throws IOException on error
* @since 3.1
*/
protected void _prepareDataSocket_(final Socket socket) throws IOException {
}
/**
* Check the value that can be set in PROT Command value.
*
* @param prot Data Channel Protection Level.
* @return True - A set point is right / False - A set point is not right
*/
private boolean checkPROTValue(final String prot) {
for (final String element : PROT_COMMAND_VALUE) {
if (element.equals(prot)) {
return true;
}
}
return false;
}
/**
* Close open sockets.
*
* @param socket main socket for proxy if enabled
* @param sslSocket ssl socket
* @throws IOException closing sockets is not successful
*/
private void closeSockets(final Socket socket, final Socket sslSocket) throws IOException {
if (socket != null) {
socket.close();
}
if (sslSocket != null) {
sslSocket.close();
}
}
/**
* Create SSL socket from plain socket.
*
* @param socket
* @return SSL Socket
* @throws IOException
*/
private SSLSocket createSSLSocket(final Socket socket) throws IOException {
if (socket != null) {
final SSLSocketFactory f = context.getSocketFactory();
return (SSLSocket) f.createSocket(socket, _hostname_, socket.getPort(), false);
}
return null;
}
/**
* Closes the connection to the FTP server and restores connection parameters to the default values.
*
* Calls {@code setSocketFactory(null)} and {@code setServerSocketFactory(null)} to reset the factories that may have been changed during the session, e.g.
* by {@link #execPROT(String)}
*
* @throws IOException If an error occurs while disconnecting.
* @since 3.0
*/
@Override
public void disconnect() throws IOException {
super.disconnect();
if (plainSocket != null) {
plainSocket.close();
}
setSocketFactory(null);
setServerSocketFactory(null);
}
/**
* Send the ADAT command with the specified authentication data.
*
* @param data The data to send with the command.
* @return server reply.
* @throws IOException If an I/O error occurs while sending the command.
* @since 3.0
*/
public int execADAT(final byte[] data) throws IOException {
if (data != null) {
return sendCommand(CMD_ADAT, Base64.encodeBase64StringUnChunked(data));
}
return sendCommand(CMD_ADAT);
}
/**
* AUTH command.
*
* @throws SSLException If it server reply code not equal "234" and "334".
* @throws IOException If an I/O error occurs while either sending the command.
*/
protected void execAUTH() throws SSLException, IOException {
final int replyCode = sendCommand(CMD_AUTH, auth);
if (FTPReply.SECURITY_MECHANISM_IS_OK == replyCode) {
// replyCode = 334
// I carry out an ADAT command.
} else if (FTPReply.SECURITY_DATA_EXCHANGE_COMPLETE != replyCode) {
throw new SSLException(getReplyString());
}
}
/**
* Send the AUTH command with the specified mechanism.
*
* @param mechanism The mechanism name to send with the command.
* @return server reply.
* @throws IOException If an I/O error occurs while sending the command.
* @since 3.0
*/
public int execAUTH(final String mechanism) throws IOException {
return sendCommand(CMD_AUTH, mechanism);
}
/**
* Send the CCC command to the server. The CCC (Clear Command Channel) command causes the underlying {@link SSLSocket} instance to be assigned to a plain
* {@link Socket} instances
*
* @return server reply.
* @throws IOException If an I/O error occurs while sending the command.
* @since 3.0
*/
public int execCCC() throws IOException {
final int repCode = sendCommand(CMD_CCC);
// This will be performed by sendCommand(String, String)
// if (FTPReply.isPositiveCompletion(repCode)) {
// _socket_.close();
// _socket_ = plainSocket;
// _controlInput_ = new BufferedReader(
// new InputStreamReader(
// _socket_.getInputStream(), getControlEncoding()));
// _controlOutput_ = new BufferedWriter(
// new OutputStreamWriter(
// _socket_.getOutputStream(), getControlEncoding()));
// }
return repCode;
}
/**
* Send the CONF command with the specified data.
*
* @param data The data to send with the command.
* @return server reply.
* @throws IOException If an I/O error occurs while sending the command.
* @since 3.0
*/
public int execCONF(final byte[] data) throws IOException {
if (data != null) {
return sendCommand(CMD_CONF, Base64.encodeBase64StringUnChunked(data));
}
return sendCommand(CMD_CONF, ""); // perhaps "=" or just sendCommand(String)?
}
/**
* Send the ENC command with the specified data.
*
* @param data The data to send with the command.
* @return server reply.
* @throws IOException If an I/O error occurs while sending the command.
* @since 3.0
*/
public int execENC(final byte[] data) throws IOException {
if (data != null) {
return sendCommand(CMD_ENC, Base64.encodeBase64StringUnChunked(data));
}
return sendCommand(CMD_ENC, ""); // perhaps "=" or just sendCommand(String)?
}
/**
* Send the MIC command with the specified data.
*
* @param data The data to send with the command.
* @return server reply.
* @throws IOException If an I/O error occurs while sending the command.
* @since 3.0
*/
public int execMIC(final byte[] data) throws IOException {
if (data != null) {
return sendCommand(CMD_MIC, Base64.encodeBase64StringUnChunked(data));
}
return sendCommand(CMD_MIC, ""); // perhaps "=" or just sendCommand(String)?
}
/**
* PBSZ command. pbsz value: 0 to (2^32)-1 decimal integer.
*
* @param pbsz Protection Buffer Size.
* @throws SSLException If the server reply code does not equal "200".
* @throws IOException If an I/O error occurs while sending the command.
* @see #parsePBSZ(long)
*/
public void execPBSZ(final long pbsz) throws SSLException, IOException {
if (pbsz < 0 || 4294967295L < pbsz) { // 32-bit unsigned number
throw new IllegalArgumentException();
}
final int status = sendCommand(CMD_PBSZ, String.valueOf(pbsz));
if (FTPReply.COMMAND_OK != status) {
throw new SSLException(getReplyString());
}
}
/**
* PROT command.
*
* This abstract class implements the common timestamp parsing algorithm for all the concrete parsers. Classes derived from this one will parse file listings
* via a supplied regular expression that pulls out the date portion as a separate string which is passed to the underlying {@link FTPTimestampParser delegate}
* to handle parsing of the file timestamp.
*
* This class also implements the {@link Configurable Configurable} interface to allow the parser to be configured from the outside.
*
* @since 1.4
*/
public abstract class ConfigurableFTPFileEntryParserImpl extends RegexFTPFileEntryParserImpl implements Configurable {
private final FTPTimestampParser timestampParser;
/**
* constructor for this abstract class.
*
* @param regex Regular expression used main parsing of the file listing.
*/
public ConfigurableFTPFileEntryParserImpl(final String regex) {
super(regex);
this.timestampParser = new FTPTimestampParserImpl();
}
/**
* constructor for this abstract class.
*
* @param regex Regular expression used main parsing of the file listing.
* @param flags the flags to apply, see {@link java.util.regex.Pattern#compile(String, int) Pattern#compile(String, int)}. Use 0 for none.
* @since 3.4
*/
public ConfigurableFTPFileEntryParserImpl(final String regex, final int flags) {
super(regex, flags);
this.timestampParser = new FTPTimestampParserImpl();
}
/**
* Implementation of the {@link Configurable Configurable} interface. Configures this parser by delegating to the underlying Configurable FTPTimestampParser
* implementation, ' passing it the supplied {@link FTPClientConfig FTPClientConfig} if that is non-null or a default configuration defined by each concrete
* subclass.
*
* @param config the configuration to be used to configure this parser. If it is null, a default configuration defined by each concrete subclass is used
* instead.
*/
@Override
public void configure(final FTPClientConfig config) {
if (this.timestampParser instanceof Configurable) {
final FTPClientConfig defaultCfg = getDefaultConfiguration();
if (config != null) {
if (null == config.getDefaultDateFormatStr()) {
config.setDefaultDateFormatStr(defaultCfg.getDefaultDateFormatStr());
}
if (null == config.getRecentDateFormatStr()) {
config.setRecentDateFormatStr(defaultCfg.getRecentDateFormatStr());
}
((Configurable) this.timestampParser).configure(config);
} else {
((Configurable) this.timestampParser).configure(defaultCfg);
}
}
}
/**
* Each concrete subclass must define this member to create a default configuration to be used when that subclass is instantiated without a
* {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for the subclass.
*/
protected abstract FTPClientConfig getDefaultConfiguration();
/**
* This method is called by the concrete parsers to delegate timestamp parsing to the timestamp parser.
*
* @param timestampStr the timestamp string pulled from the file listing by the regular expression parser, to be submitted to the
*
* Implementation extracts a key from the supplied {@link FTPClientConfig FTPClientConfig} parameter and creates an object implementing the interface
* FTPFileEntryParser and uses the supplied configuration to configure it.
*
* Note that this method will generally not be called in scenarios that call for autodetection of parser type but rather, for situations where the user
* knows that the server uses a non-default configuration and knows what that configuration is.
*
* If
* Note: EnterpriseUnixFTPEntryParser can only be instantiated through the DefaultFTPParserFactory by classname. It will not be chosen by the autodetection
* scheme.
*
* Implementation should be a method that extracts a key from the supplied {@link FTPClientConfig FTPClientConfig} parameter and creates an object
* implementing the interface FTPFileEntryParser and uses the supplied configuration to configure it.
*
* Note that this method will generally not be called in scenarios that call for autodetection of parser type but rather, for situations where the user
* knows that the server uses a non-default configuration and knows what that configuration is.
*
* Set up the {@link FTPClientConfig#setDefaultDateFormatStr(java.lang.String) defaultDateFormat} and optionally the
* {@link FTPClientConfig#setRecentDateFormatStr(String) recentDateFormat} to values supplied in the config based on month names configured as follows:
*
* Finally if a {@link org.apache.commons.net.ftp.FTPClientConfig#setServerTimeZoneId(String) serverTimeZoneId} has been supplied via the config, set that
* into all date formats that have been configured.
*
* Format is as follows:
*
* A single control response entry (MLST) is returned with a leading space; multiple (data) entries are returned without any leading spaces. The parser requires
* that the leading space from the MLST entry is removed. MLSD entries can begin with a single space if there are no facts.
*
* Netware file permissions are in the following format: RWCEAFMS, and are explained as follows:
*
* For now end users may specify this format only via
* Note: VMSFTPEntryParser can only be instantiated through the DefaultFTPParserFactory by classname. It will not be chosen by the autodetection scheme.
*
* This is a sample of VMS LIST output
*
* Implementation of IMAPChunkListener that returns {@code true} but otherwise does nothing.
*
* This is intended for use with a suitable ProtocolCommandListener. If the IMAP response contains multiple-line data, the protocol listener will be called
* for each multi-line chunk. The accumulated reply data will be cleared after calling the listener. If the response is very long, this can significantly
* reduce memory requirements. The listener will also start receiving response data earlier, as it does not have to wait for the entire response to be read.
*
* The ProtocolCommandListener must be prepared to accept partial responses. This should not be a problem for listeners that just log the input.
*
* This class handles stripping of the duplicate period at the beginning of lines starting with a period, and ensures you cannot read past the end of the
* message.
*
* Note: versions since 3.0 extend BufferedReader rather than Reader, and no longer change the CRLF into the local EOL. Also only DOT CR LF acts as EOF.
*/
public final class DotTerminatedMessageReader extends BufferedReader {
private static final char LF = '\n';
private static final char CR = '\r';
private static final int DOT = '.';
private boolean atBeginning;
private boolean eof;
private boolean seenCR; // was last character CR?
/**
* Creates a DotTerminatedMessageReader that wraps an existing Reader input source.
*
* @param reader The Reader input source containing the message.
*/
public DotTerminatedMessageReader(final Reader reader) {
super(reader);
// Assumes input is at start of message
atBeginning = true;
eof = false;
}
/**
* Closes the message for reading. This doesn't actually close the underlying stream. The underlying stream may still be used for communicating with the
* server and therefore is not closed.
*
* If the end of the message has not yet been reached, this method will read the remainder of the message until it reaches the end, so that the underlying
* stream may continue to be used properly for communicating with the server. If you do not fully read a message, you MUST close it, otherwise your program
* will likely hang or behave improperly.
*
* @throws IOException If an error occurs while reading the underlying stream.
*/
@Override
public void close() throws IOException {
synchronized (lock) {
if (!eof) {
while (read() != -1) {
// read to EOF
}
}
eof = true;
atBeginning = false;
}
}
/**
* Reads and returns the next character in the message. If the end of the message has been reached, returns -1. Note that a call to this method may result
* in multiple reads from the underlying input stream to decode the message properly (removing doubled dots and so on). All of this is transparent to the
* programmer and is only mentioned for completeness.
*
* @return The next character in the message. Returns -1 if the end of the message has been reached.
* @throws IOException If an error occurs while reading the underlying stream.
*/
@Override
public int read() throws IOException {
synchronized (lock) {
if (eof) {
return NetConstants.EOS; // Don't allow read past EOF
}
int chint = super.read();
if (chint == NetConstants.EOS) { // True EOF
eof = true;
return NetConstants.EOS;
}
if (atBeginning) {
atBeginning = false;
if (chint == DOT) { // Have DOT
mark(2); // need to check for CR LF or DOT
chint = super.read();
switch (chint) {
case NetConstants.EOS:
// new Throwable("Trailing DOT").printStackTrace();
eof = true;
return DOT; // return the trailing DOT
case DOT:
// no need to reset as we want to lose the first DOT
return chint; // i.e. DOT
case CR:
chint = super.read();
if (chint == NetConstants.EOS) { // Still only DOT CR - should not happen
// new Throwable("Trailing DOT CR").printStackTrace();
reset(); // So CR is picked up next time
return DOT; // return the trailing DOT
}
if (chint == LF) { // DOT CR LF
atBeginning = true;
eof = true;
// Do we need to clear the mark somehow?
return NetConstants.EOS;
}
break;
default:
break;
}
// Should not happen - lone DOT at beginning
// new Throwable("Lone DOT followed by "+(char)chint).printStackTrace();
reset();
return DOT;
} // have DOT
} // atBeginning
// Handle CRLF in normal flow
if (seenCR) {
seenCR = false;
if (chint == LF) {
atBeginning = true;
}
}
if (chint == CR) {
seenCR = true;
}
return chint;
}
}
/**
* Reads the next characters from the message into an array and returns the number of characters read. Returns -1 if the end of the message has been
* reached.
*
* @param buffer The character array in which to store the characters.
* @return The number of characters read. Returns -1 if the end of the message has been reached.
* @throws IOException If an error occurs in reading the underlying stream.
*/
@Override
public int read(final char[] buffer) throws IOException {
return read(buffer, 0, buffer.length);
}
/**
* Reads the next characters from the message into an array and returns the number of characters read. Returns -1 if the end of the message has been
* reached. The characters are stored in the array starting from the given offset and up to the length specified.
*
* @param buffer The character array in which to store the characters.
* @param offset The offset into the array at which to start storing characters.
* @param length The number of characters to read.
* @return The number of characters read. Returns -1 if the end of the message has been reached.
* @throws IOException If an error occurs in reading the underlying stream.
*/
@Override
public int read(final char[] buffer, int offset, int length) throws IOException {
if (length < 1) {
return 0;
}
int ch;
synchronized (lock) {
if ((ch = read()) == -1) {
return NetConstants.EOS;
}
final int off = offset;
do {
buffer[offset++] = (char) ch;
} while (--length > 0 && (ch = read()) != -1);
return offset - off;
}
}
/**
* Read a line of text. A line is considered to be terminated by carriage return followed immediately by a linefeed. This contrasts with BufferedReader
* which also allows other combinations.
*
* @since 3.0
*/
@Override
public String readLine() throws IOException {
final StringBuilder sb = new StringBuilder();
int intch;
synchronized (lock) { // make thread-safe (hopefully!)
while ((intch = read()) != NetConstants.EOS) {
if (intch == LF && atBeginning) {
return sb.substring(0, sb.length() - 1);
}
sb.append((char) intch);
}
}
final String string = sb.toString();
if (string.isEmpty()) { // immediate EOF
return null;
}
// Should not happen - EOF without CRLF
// new Throwable(string).printStackTrace();
return string;
}
}
DotTerminatedMessageWriter.java 0000664 0000000 0000000 00000014317 14340477222 0034357 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io /*
* 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.io;
import java.io.IOException;
import java.io.Writer;
/**
* DotTerminatedMessageWriter is a class used to write messages to a server that are terminated by a single dot followed by a <CR><LF> sequence and
* with double dots appearing at the begining of lines which do not signal end of message yet start with a dot. Various Internet protocols such as NNTP and POP3
* produce messages of this type.
*
* This class handles the doubling of line-starting periods, converts single linefeeds to NETASCII newlines, and on closing will send the final message
* terminator dot and NETASCII newline sequence.
*
*
*/
public final class DotTerminatedMessageWriter extends Writer {
private static final int NOTHING_SPECIAL_STATE = 0;
private static final int LAST_WAS_CR_STATE = 1;
private static final int LAST_WAS_NL_STATE = 2;
private int state;
private Writer output;
/**
* Creates a DotTerminatedMessageWriter that wraps an existing Writer output destination.
*
* @param output The Writer output destination to write the message.
*/
public DotTerminatedMessageWriter(final Writer output) {
super(output);
this.output = output;
this.state = NOTHING_SPECIAL_STATE;
}
/**
* Flushes the underlying output, writing all buffered output, but doesn't actually close the underlying stream. The underlying stream may still be used for
* communicating with the server and therefore is not closed.
*
* @throws IOException If an error occurs while writing to the underlying output or closing the Writer.
*/
@Override
public void close() throws IOException {
synchronized (lock) {
if (output == null) {
return;
}
if (state == LAST_WAS_CR_STATE) {
output.write('\n');
} else if (state != LAST_WAS_NL_STATE) {
output.write("\r\n");
}
output.write(".\r\n");
output.flush();
output = null;
}
}
/**
* Flushes the underlying output, writing all buffered output.
*
* @throws IOException If an error occurs while writing to the underlying output.
*/
@Override
public void flush() throws IOException {
synchronized (lock) {
output.flush();
}
}
/**
* Writes a character array to the output.
*
* @param buffer The character array to write.
* @throws IOException If an error occurs while writing to the underlying output.
*/
@Override
public void write(final char[] buffer) throws IOException {
write(buffer, 0, buffer.length);
}
/**
* Writes a number of characters from a character array to the output starting from a given offset.
*
* @param buffer The character array to write.
* @param offset The offset into the array at which to start copying data.
* @param length The number of characters to write.
* @throws IOException If an error occurs while writing to the underlying output.
*/
@Override
public void write(final char[] buffer, int offset, int length) throws IOException {
synchronized (lock) {
while (length-- > 0) {
write(buffer[offset++]);
}
}
}
/**
* Writes a character to the output. Note that a call to this method may result in multiple writes to the underling Writer in order to convert naked
* linefeeds to NETASCII line separators and to double line-leading periods. This is transparent to the programmer and is only mentioned for completeness.
*
* @param ch The character to write.
* @throws IOException If an error occurs while writing to the underlying output.
*/
@Override
public void write(final int ch) throws IOException {
synchronized (lock) {
switch (ch) {
case '\r':
state = LAST_WAS_CR_STATE;
output.write('\r');
return;
case '\n':
if (state != LAST_WAS_CR_STATE) {
output.write('\r');
}
output.write('\n');
state = LAST_WAS_NL_STATE;
return;
case '.':
// Double the dot at the beginning of a line
if (state == LAST_WAS_NL_STATE) {
output.write('.');
}
//$FALL-THROUGH$
default:
state = NOTHING_SPECIAL_STATE;
output.write(ch);
}
}
}
/**
* Writes a String to the output.
*
* @param string The String to write.
* @throws IOException If an error occurs while writing to the underlying output.
*/
@Override
public void write(final String string) throws IOException {
write(string.toCharArray());
}
/**
* Writes part of a String to the output starting from a given offset.
*
* @param string The String to write.
* @param offset The offset into the String at which to start copying data.
* @param length The number of characters to write.
* @throws IOException If an error occurs while writing to the underlying output.
*/
@Override
public void write(final String string, final int offset, final int length) throws IOException {
write(string.toCharArray(), offset, length);
}
}
FromNetASCIIInputStream.java 0000664 0000000 0000000 00000014502 14340477222 0033425 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io /*
* 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.io;
import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackInputStream;
import java.nio.charset.StandardCharsets;
import org.apache.commons.net.util.NetConstants;
/**
* This class wraps an input stream, replacing all occurrences of <CR><LF> (carriage return followed by a linefeed), which is the NETASCII standard
* for representing a newline, with the local line separator representation. You would use this class to implement ASCII file transfers requiring conversion
* from NETASCII.
*
*
*/
public final class FromNetASCIIInputStream extends PushbackInputStream {
static final boolean _noConversionRequired;
static final String _lineSeparator;
static final byte[] _lineSeparatorBytes;
static {
_lineSeparator = System.lineSeparator();
_noConversionRequired = _lineSeparator.equals("\r\n");
_lineSeparatorBytes = _lineSeparator.getBytes(StandardCharsets.US_ASCII);
}
/**
* Returns true if the NetASCII line separator differs from the system line separator, false if they are the same. This method is useful to determine
* whether or not you need to instantiate a FromNetASCIIInputStream object.
*
* @return True if the NETASCII line separator differs from the local system line separator, false if they are the same.
*/
public static boolean isConversionRequired() {
return !_noConversionRequired;
}
private int length;
/**
* Creates a FromNetASCIIInputStream instance that wraps an existing InputStream.
*
* @param input the stream to wrap
*/
public FromNetASCIIInputStream(final InputStream input) {
super(input, _lineSeparatorBytes.length + 1);
}
// PushbackInputStream in JDK 1.1.3 returns the wrong thing
// TODO - can we delete this override now?
/**
* Returns the number of bytes that can be read without blocking EXCEPT when newline conversions have to be made somewhere within the available block of
* bytes. In other words, you really should not rely on the value returned by this method if you are trying to avoid blocking.
*/
@Override
public int available() throws IOException {
if (in == null) {
throw new IOException("Stream closed");
}
return buf.length - pos + in.available();
}
/**
* Reads and returns the next byte in the stream. If the end of the message has been reached, returns -1. Note that a call to this method may result in
* multiple reads from the underlying input stream in order to convert NETASCII line separators to the local line separator format. This is transparent to
* the programmer and is only mentioned for completeness.
*
* @return The next character in the stream. Returns -1 if the end of the stream has been reached.
* @throws IOException If an error occurs while reading the underlying stream.
*/
@Override
public int read() throws IOException {
if (_noConversionRequired) {
return super.read();
}
return readInt();
}
/**
* Reads the next number of bytes from the stream into an array and returns the number of bytes read. Returns -1 if the end of the stream has been reached.
*
* @param buffer The byte array in which to store the data.
* @return The number of bytes read. Returns -1 if the end of the message has been reached.
* @throws IOException If an error occurs in reading the underlying stream.
*/
@Override
public int read(final byte buffer[]) throws IOException {
return read(buffer, 0, buffer.length);
}
/**
* Reads the next number of bytes from the stream into an array and returns the number of bytes read. Returns -1 if the end of the message has been reached.
* The characters are stored in the array starting from the given offset and up to the length specified.
*
* @param buffer The byte array in which to store the data.
* @param offset The offset into the array at which to start storing data.
* @param length The number of bytes to read.
* @return The number of bytes read. Returns -1 if the end of the stream has been reached.
* @throws IOException If an error occurs while reading the underlying stream.
*/
@Override
public int read(final byte buffer[], int offset, final int length) throws IOException {
if (_noConversionRequired) {
return super.read(buffer, offset, length);
}
if (length < 1) {
return 0;
}
int ch;
final int off;
ch = available();
this.length = Math.min(length, ch);
// If nothing is available, block to read only one character
if (this.length < 1) {
this.length = 1;
}
if ((ch = readInt()) == -1) {
return NetConstants.EOS;
}
off = offset;
do {
buffer[offset++] = (byte) ch;
} while (--this.length > 0 && (ch = readInt()) != -1);
return offset - off;
}
private int readInt() throws IOException {
int ch;
ch = super.read();
if (ch == '\r') {
ch = super.read();
if (ch != '\n') {
if (ch != -1) {
unread(ch);
}
return '\r';
}
unread(_lineSeparatorBytes);
ch = super.read();
// This is a kluge for read(byte[], ...) to read the right amount
--length;
}
return ch;
}
}
FromNetASCIIOutputStream.java 0000664 0000000 0000000 00000011402 14340477222 0033622 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io /*
* 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.io;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* This class wraps an output stream, replacing all occurrences of <CR><LF> (carriage return followed by a linefeed), which is the NETASCII standard
* for representing a newline, with the local line separator representation. You would use this class to implement ASCII file transfers requiring conversion
* from NETASCII.
*
* Because of the translation process, a call to
* The contents of the Reader are read until its end is reached, but neither the source nor the destination are closed. You must do this yourself outside of
* the method call. The number of characters read/written is returned.
*
* @param source The source Reader.
* @param dest The destination writer.
* @param bufferSize The number of characters to buffer during the copy. A zero or negative value means to use {@link #DEFAULT_COPY_BUFFER_SIZE}.
* @param streamSize The number of characters in the stream being copied. Should be set to CopyStreamEvent.UNKNOWN_STREAM_SIZE if unknown. Not currently
* used (though it is passed to {@link CopyStreamListener#bytesTransferred(long, int, long)}
* @param listener The CopyStreamListener to notify of progress. If this parameter is null, notification is not attempted.
* @return The number of characters read/written in the copy operation.
* @throws CopyStreamException If an error occurs while reading from the source or writing to the destination. The CopyStreamException will contain the
* number of bytes confirmed to have been transferred before an IOException occurred, and it will also contain the IOException
* that caused the error. These values can be retrieved with the CopyStreamException getTotalBytesTransferred() and
* getIOException() methods.
*/
public static long copyReader(final Reader source, final Writer dest, final int bufferSize, final long streamSize, final CopyStreamListener listener)
throws CopyStreamException {
int numChars;
long total = 0;
final char[] buffer = new char[bufferSize > 0 ? bufferSize : DEFAULT_COPY_BUFFER_SIZE];
try {
while ((numChars = source.read(buffer)) != NetConstants.EOS) {
// Technically, some read(char[]) methods may return 0 and we cannot
// accept that as an indication of EOF.
if (numChars == 0) {
final int singleChar = source.read();
if (singleChar < 0) {
break;
}
dest.write(singleChar);
dest.flush();
++total;
if (listener != null) {
listener.bytesTransferred(total, 1, streamSize);
}
continue;
}
dest.write(buffer, 0, numChars);
dest.flush();
total += numChars;
if (listener != null) {
listener.bytesTransferred(total, numChars, streamSize);
}
}
} catch (final IOException e) {
throw new CopyStreamException("IOException caught while copying.", total, e);
}
return total;
}
/**
* Same as
* The contents of the InputStream are read until the end of the stream is reached, but neither the source nor the destination are closed. You must do this
* yourself outside of the method call. The number of bytes read/written is returned.
*
* @param source The source InputStream.
* @param dest The destination OutputStream.
* @param bufferSize The number of bytes to buffer during the copy. A zero or negative value means to use {@link #DEFAULT_COPY_BUFFER_SIZE}.
* @param streamSize The number of bytes in the stream being copied. Should be set to CopyStreamEvent.UNKNOWN_STREAM_SIZE if unknown. Not currently used
* (though it is passed to {@link CopyStreamListener#bytesTransferred(long, int, long)}
* @param listener The CopyStreamListener to notify of progress. If this parameter is null, notification is not attempted.
* @return number of bytes read/written
* @throws CopyStreamException If an error occurs while reading from the source or writing to the destination. The CopyStreamException will contain the
* number of bytes confirmed to have been transferred before an IOException occurred, and it will also contain the IOException
* that caused the error. These values can be retrieved with the CopyStreamException getTotalBytesTransferred() and
* getIOException() methods.
*/
public static long copyStream(final InputStream source, final OutputStream dest, final int bufferSize, final long streamSize,
final CopyStreamListener listener) throws CopyStreamException {
return copyStream(source, dest, bufferSize, streamSize, listener, true);
}
/**
* Copies the contents of an InputStream to an OutputStream using a copy buffer of a given size and notifies the provided CopyStreamListener of the progress
* of the copy operation by calling its bytesTransferred(long, int) method after each write to the destination. If you wish to notify more than one listener
* you should use a CopyStreamAdapter as the listener and register the additional listeners with the CopyStreamAdapter.
*
* The contents of the InputStream are read until the end of the stream is reached, but neither the source nor the destination are closed. You must do this
* yourself outside of the method call. The number of bytes read/written is returned.
*
* @param source The source InputStream.
* @param dest The destination OutputStream.
* @param bufferSize The number of bytes to buffer during the copy. A zero or negative value means to use {@link #DEFAULT_COPY_BUFFER_SIZE}.
* @param streamSize The number of bytes in the stream being copied. Should be set to CopyStreamEvent.UNKNOWN_STREAM_SIZE if unknown. Not currently used
* (though it is passed to {@link CopyStreamListener#bytesTransferred(long, int, long)}
* @param listener The CopyStreamListener to notify of progress. If this parameter is null, notification is not attempted.
* @param flush Whether to flush the output stream after every write. This is necessary for interactive sessions that rely on buffered streams. If you
* don't flush, the data will stay in the stream buffer.
* @return number of bytes read/written
* @throws CopyStreamException If an error occurs while reading from the source or writing to the destination. The CopyStreamException will contain the
* number of bytes confirmed to have been transferred before an IOException occurred, and it will also contain the IOException
* that caused the error. These values can be retrieved with the CopyStreamException getTotalBytesTransferred() and
* getIOException() methods.
*/
public static long copyStream(final InputStream source, final OutputStream dest, final int bufferSize, final long streamSize,
final CopyStreamListener listener, final boolean flush) throws CopyStreamException {
int numBytes;
long total = 0;
final byte[] buffer = new byte[bufferSize > 0 ? bufferSize : DEFAULT_COPY_BUFFER_SIZE];
try {
while ((numBytes = source.read(buffer)) != NetConstants.EOS) {
// Technically, some read(byte[]) methods may return 0 and we cannot
// accept that as an indication of EOF.
if (numBytes == 0) {
final int singleByte = source.read();
if (singleByte < 0) {
break;
}
dest.write(singleByte);
if (flush) {
dest.flush();
}
++total;
if (listener != null) {
listener.bytesTransferred(total, 1, streamSize);
}
continue;
}
dest.write(buffer, 0, numBytes);
if (flush) {
dest.flush();
}
total += numBytes;
if (listener != null) {
listener.bytesTransferred(total, numBytes, streamSize);
}
}
} catch (final IOException e) {
throw new CopyStreamException("IOException caught while copying.", total, e);
}
return total;
}
// Cannot be instantiated
private Util() {
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/package-info.java 0000664 0000000 0000000 00000001561 14340477222 0031512 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Utility classes for IO support.
*/
package org.apache.commons.net.io; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/ 0000775 0000000 0000000 00000000000 14340477222 0026670 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/Article.java 0000664 0000000 0000000 00000020131 14340477222 0031113 0 ustar 00root root 0000000 0000000 /*
* 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.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import org.apache.commons.net.util.NetConstants;
/**
* This is a class that contains the basic state needed for message retrieval and threading. With thanks to Jamie Zawinski (jwz@jwz.org)
*/
public class Article implements Threadable {
/**
* Recursive method that traverses a pre-threaded graph (or tree) of connected Article objects and prints them out.
*
* @param article the root of the article 'tree'
* @since 3.4
*/
public static void printThread(final Article article) {
printThread(article, 0, System.out);
}
/**
* Recursive method that traverses a pre-threaded graph (or tree) of connected Article objects and prints them out.
*
* @param article the root of the article 'tree'
* @param depth the current tree depth
*/
public static void printThread(final Article article, final int depth) {
printThread(article, depth, System.out);
}
/**
* Recursive method that traverses a pre-threaded graph (or tree) of connected Article objects and prints them out.
*
* @param article the root of the article 'tree'
* @param depth the current tree depth
* @param ps the PrintStream to use
* @since 3.4
*/
public static void printThread(final Article article, final int depth, final PrintStream ps) {
for (int i = 0; i < depth; ++i) {
ps.print("==>");
}
ps.println(article.getSubject() + "\t" + article.getFrom() + "\t" + article.getArticleId());
if (article.kid != null) {
printThread(article.kid, depth + 1);
}
if (article.next != null) {
printThread(article.next, depth);
}
}
/**
* Recursive method that traverses a pre-threaded graph (or tree) of connected Article objects and prints them out.
*
* @param article the root of the article 'tree'
* @param ps the PrintStream to use
* @since 3.4
*/
public static void printThread(final Article article, final PrintStream ps) {
printThread(article, 0, ps);
}
private long articleNumber;
private String subject;
private String date;
private String articleId;
private String simplifiedSubject;
private String from;
private ArrayList
* 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} .
* 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
*
* @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.
*
*
* @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.
*
*
* @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)
*
*
* @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)
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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 }.
*
*
* @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 }.
*
*
* @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 }.
*
*
* @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 }.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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.
*
*
* @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);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/NNTPClient.java 0000664 0000000 0000000 00000225035 14340477222 0031460 0 ustar 00root root 0000000 0000000 /*
* 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.IOException;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Vector;
import org.apache.commons.net.MalformedServerReplyException;
import org.apache.commons.net.io.DotTerminatedMessageReader;
import org.apache.commons.net.io.DotTerminatedMessageWriter;
import org.apache.commons.net.io.Util;
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
* 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}.
*
* 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} .
* 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 NNTP
* @see NNTPConnectionClosedException
* @see org.apache.commons.net.MalformedServerReplyException
*/
public class NNTPClient extends NNTP {
private static final NewsgroupInfo[] EMPTY_NEWSGROUP_INFO_ARRAY = {};
/**
* Parse a response line from {@link #retrieveArticleInfo(long, long)}.
*
* @param line a response line
* @return the parsed {@link Article}, if unparseable then isDummy() will be true, and the subject will contain the raw info.
* @since 3.0
*/
static Article parseArticleEntry(final String line) {
// Extract the article information
// Mandatory format (from NNTP RFC 2980) is :
// articleNumber\tSubject\tAuthor\tDate\tID\tReference(s)\tByte Count\tLine Count
final Article article = new Article();
article.setSubject(line); // in case parsing fails
final String parts[] = line.split("\t");
if (parts.length > 6) {
int i = 0;
try {
article.setArticleNumber(Long.parseLong(parts[i++]));
article.setSubject(parts[i++]);
article.setFrom(parts[i++]);
article.setDate(parts[i++]);
article.setArticleId(parts[i++]);
article.addReference(parts[i++]);
} catch (final NumberFormatException e) {
// ignored, already handled
}
}
return article;
}
/*
* 211 n f l s group selected (n = estimated number of articles in group, f = first article number in the group, l = last article number in the group, s =
* name of the group.)
*/
private static void parseGroupReply(final String reply, final NewsgroupInfo info) throws MalformedServerReplyException {
final String tokens[] = reply.split(" ");
if (tokens.length >= 5) {
int i = 1; // Skip numeric response value
try {
// Get estimated article count
info.setArticleCount(Long.parseLong(tokens[i++]));
// Get first article number
info.setFirstArticle(Long.parseLong(tokens[i++]));
// Get last article number
info.setLastArticle(Long.parseLong(tokens[i++]));
// Get newsgroup name
info.setNewsgroup(tokens[i++]);
info.setPostingPermission(NewsgroupInfo.UNKNOWN_POSTING_PERMISSION);
return;
} catch (final NumberFormatException e) {
// drop through to report error
}
}
throw new MalformedServerReplyException("Could not parse newsgroup info.\nServer reply: " + reply);
}
// Format: group last first p
static NewsgroupInfo parseNewsgroupListEntry(final String entry) {
final String tokens[] = entry.split(" ");
if (tokens.length < 4) {
return null;
}
final NewsgroupInfo result = new NewsgroupInfo();
int i = 0;
result.setNewsgroup(tokens[i++]);
try {
final long lastNum = Long.parseLong(tokens[i++]);
final long firstNum = Long.parseLong(tokens[i++]);
result.setFirstArticle(firstNum);
result.setLastArticle(lastNum);
if ((firstNum == 0) && (lastNum == 0)) {
result.setArticleCount(0);
} else {
result.setArticleCount(lastNum - firstNum + 1);
}
} catch (final NumberFormatException e) {
return null;
}
switch (tokens[i++].charAt(0)) {
case 'y':
case 'Y':
result.setPostingPermission(NewsgroupInfo.PERMITTED_POSTING_PERMISSION);
break;
case 'n':
case 'N':
result.setPostingPermission(NewsgroupInfo.PROHIBITED_POSTING_PERMISSION);
break;
case 'm':
case 'M':
result.setPostingPermission(NewsgroupInfo.MODERATED_POSTING_PERMISSION);
break;
default:
result.setPostingPermission(NewsgroupInfo.UNKNOWN_POSTING_PERMISSION);
break;
}
return result;
}
@SuppressWarnings("deprecation")
private void ai2ap(final ArticleInfo ai, final ArticlePointer ap) {
if (ap != null) { // ai cannot be null
ap.articleId = ai.articleId;
ap.articleNumber = (int) ai.articleNumber;
}
}
private ArticleInfo ap2ai(@SuppressWarnings("deprecation") final ArticlePointer ap) {
if (ap == null) {
return null;
}
final ArticleInfo ai = new ArticleInfo();
return ai;
}
/**
* Log into a news server by sending the AUTHINFO USER/AUTHINFO PASS command sequence. This is usually sent in response to a 480 reply code from the NNTP
* server.
*
*
* @param username a valid username
* @param password the corresponding password
* @return True for successful login, false for a failure
* @throws IOException on error
*/
public boolean authenticate(final String username, final String password) throws IOException {
int replyCode = authinfoUser(username);
if (replyCode == NNTPReply.MORE_AUTH_INFO_REQUIRED) {
replyCode = authinfoPass(password);
if (replyCode == NNTPReply.AUTHENTICATION_ACCEPTED) {
this._isAllowedToPost = true;
return true;
}
}
return false;
}
/**
* There are a few NNTPClient methods that do not complete the entire sequence of NNTP commands to complete a transaction. These commands require some
* action by the programmer after the reception of a positive preliminary 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.
*
* For example
*
*
*
* @return True if successfully completed, false if not.
* @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 a command to the server or receiving a reply from the server.
*/
public boolean completePendingCommand() throws IOException {
return NNTPReply.isPositiveCompletion(getReply());
}
public Writer forwardArticle(final String articleId) throws IOException {
if (!NNTPReply.isPositiveIntermediate(ihave(articleId))) {
return null;
}
return new DotTerminatedMessageWriter(_writer_);
}
/**
* Return article headers for all articles between lowArticleNumber and highArticleNumber, inclusively, using the XOVER command.
*
*
* @param lowArticleNumber low
* @param highArticleNumber high
* @return an Iterable of Articles
* @throws IOException if the command failed
* @since 3.0
*/
public Iterable
*
* @param query The query restricting how to search for new news. You must add at least one newsgroup to the query.
* @return An iterator of String instances containing the unique message identifiers for each new article added to the NNTP server. If no new news is found,
* no strings will be returned.
* @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 a command to the server or receiving a reply from the server.
* @since 3.0
*/
public Iterable
*
* @param query The query restricting how to search for new newsgroups.
* @return An iterable of Strings containing the raw information for each new newsgroup added to the NNTP server. If no newsgroups were added, no entries
* will be returned.
* @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 a command to the server or receiving a reply from the server.
* @since 3.0
*/
public Iterable
*
* @param query The query restricting how to search for new newsgroups.
* @return An iterable of NewsgroupInfo instances containing the information for each new newsgroup added to the NNTP server. If no newsgroups were added,
* no entries will be returned.
* @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 a command to the server or receiving a reply from the server.
* @since 3.0
*/
public Iterable
*
* @return An iterable of NewsgroupInfo instances containing the information for each newsgroup served by the NNTP server. If no newsgroups are served, no
* entries will be returned.
* @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 a command to the server or receiving a reply from the server.
* @since 3.0
*/
public Iterable
*
* @param wildmat a pseudo-regex pattern (cf. RFC 2980)
* @return An iterable of Strings containing the raw information for each newsgroup served by the NNTP server corresponding to the supplied pattern. If no
* such newsgroups are served, no entries will be returned.
* @throws IOException on error
* @since 3.0
*/
public Iterable
*
* @return An iterable of Strings containing the raw information for each newsgroup served by the NNTP server. If no newsgroups are served, no entries will
* be returned.
* @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 a command to the server or receiving a reply from the server.
* @since 3.0
*/
public Iterable
*
* @param wildmat a pseudo-regex pattern (cf. RFC 2980)
* @return An iterable NewsgroupInfo instances containing the information for each newsgroup served by the NNTP server corresponding to the supplied
* pattern. If no such newsgroups are served, no entries will be returned.
* @throws IOException on error
* @since 3.0
*/
public Iterable
*
* @return The sever help information.
* @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 a command to the server or receiving a reply from the server.
*/
public String listHelp() throws IOException {
if (!NNTPReply.isInformational(help())) {
return null;
}
try (final StringWriter help = new StringWriter(); final BufferedReader reader = new DotTerminatedMessageReader(_reader_)) {
Util.copyReader(reader, help);
return help.toString();
}
}
/**
* List all new articles added to the NNTP server since a particular date subject to the conditions of the specified query. If no new new news is found, a
* zero length array will be returned. If the command fails, null will be returned. You must add at least one newsgroup to the query, else the command will
* fail. Each String in the returned array is a unique message identifier including the enclosing < and >. This uses the "NEWNEWS" command.
*
*
* @param query The query restricting how to search for new news. You must add at least one newsgroup to the query.
* @return An array of String instances containing the unique message identifiers for each new article added to the NNTP server. If no new news is found, a
* zero length array will be returned. If the command fails, null will be returned.
* @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 a command to the server or receiving a reply from the server.
*
* @see #iterateNewNews(NewGroupsOrNewsQuery)
*/
public String[] listNewNews(final NewGroupsOrNewsQuery query) throws IOException {
if (!NNTPReply.isPositiveCompletion(newnews(query.getNewsgroups(), query.getDate(), query.getTime(), query.isGMT(), query.getDistributions()))) {
return null;
}
final Vector
*
* @param query The query restricting how to search for new newsgroups.
* @return An array of NewsgroupInfo instances containing the information for each new newsgroup added to the NNTP server. If no newsgroups were added, a
* zero length array will be returned. If the command fails, null will be returned.
* @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 a command to the server or receiving a reply from the server.
* @see #iterateNewNewsgroups(NewGroupsOrNewsQuery)
* @see #iterateNewNewsgroupListing(NewGroupsOrNewsQuery)
*/
public NewsgroupInfo[] listNewNewsgroups(final NewGroupsOrNewsQuery query) throws IOException {
if (!NNTPReply.isPositiveCompletion(newgroups(query.getDate(), query.getTime(), query.isGMT(), query.getDistributions()))) {
return null;
}
return readNewsgroupListing();
}
/**
* List all newsgroups served by the NNTP server. If no newsgroups are served, a zero length array will be returned. If the command fails, null will be
* returned. The method uses the "LIST" command.
*
*
* @return An array of NewsgroupInfo instances containing the information for each newsgroup served by the NNTP server. If no newsgroups are served, a zero
* length array will be returned. If the command fails, null will be returned.
* @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 a command to the server or receiving a reply from the server.
* @see #iterateNewsgroupListing()
* @see #iterateNewsgroups()
*/
public NewsgroupInfo[] listNewsgroups() throws IOException {
if (!NNTPReply.isPositiveCompletion(list())) {
return null;
}
return readNewsgroupListing();
}
/**
* List the newsgroups that match a given pattern. Uses the "LIST ACTIVE" command.
*
*
* @param wildmat a pseudo-regex pattern (cf. RFC 2980)
* @return An array of NewsgroupInfo instances containing the information for each newsgroup served by the NNTP server corresponding to the supplied
* pattern. If no such newsgroups are served, a zero length array will be returned. If the command fails, null will be returned.
* @throws IOException on error
* @see #iterateNewsgroupListing(String)
* @see #iterateNewsgroups(String)
*/
public NewsgroupInfo[] listNewsgroups(final String wildmat) throws IOException {
if (!NNTPReply.isPositiveCompletion(listActive(wildmat))) {
return null;
}
return readNewsgroupListing();
}
/**
* Send a "LIST OVERVIEW.FMT" command to the server.
*
* @return the contents of the Overview format, of {@code null} if the command failed
* @throws IOException on error
*/
public String[] listOverviewFmt() throws IOException {
if (!NNTPReply.isPositiveCompletion(sendCommand("LIST", "OVERVIEW.FMT"))) {
return null;
}
try (final BufferedReader reader = new DotTerminatedMessageReader(_reader_)) {
String line;
final ArrayList
*
* @return True if successfully completed, false if not.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean logout() throws IOException {
return NNTPReply.isPositiveCompletion(quit());
}
/**
* Parse the reply and store the id and number in the pointer.
*
* @param reply the reply to parse "22n nnn
* You must not issue any commands to the NNTP server (i.e., call any (other methods) until you finish writing to the returned Writer instance and close it.
* The NNTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned Writer actually writes directly to
* the NNTP connection. After you close the writer, you can execute new commands. If you do not follow these requirements your program will not work
* properly.
*
* Different NNTP servers will require different header formats, but you can use the provided {@link org.apache.commons.net.nntp.SimpleNNTPHeader} class to
* construct the bare minimum acceptable header for most news readers. To construct more complicated headers you should refer to RFC 822. When the Java Mail
* API is finalized, you will be able to use it to compose fully compliant Internet text messages. The DotTerminatedMessageWriter takes care of doubling
* line-leading dots and ending the message with a single dot upon closing, so all you have to worry about is writing the header and the message.
*
* Upon closing the returned Writer, you need to call {@link #completePendingCommand completePendingCommand() } to finalize the posting and verify its
* success or failure from the server reply.
*
*
* @return A DotTerminatedMessageWriter to which the article (including header) can be written. Returns null if the command fails.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public Writer postArticle() throws IOException {
if (!NNTPReply.isPositiveIntermediate(post())) {
return null;
}
return new DotTerminatedMessageWriter(_writer_);
}
private NewsgroupInfo[] readNewsgroupListing() throws IOException {
// Start of with a big vector because we may be reading a very large
// amount of groups.
final Vector
* A DotTerminatedMessageReader is returned from which the article can be read. If the article does not exist, null is returned.
*
* You must not issue any commands to the NNTP server (i.e., call any other methods) until you finish reading the message from the returned BufferedReader
* instance. The NNTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned BufferedReader actually
* reads directly from the NNTP connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
*
* @param articleNumber The number of the the article to retrieve.
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of
* server deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned
* article information.
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @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 a command to the server or receiving a reply from the server.
*/
public BufferedReader retrieveArticle(final long articleNumber, final ArticleInfo pointer) throws IOException {
return retrieve(NNTPCommand.ARTICLE, articleNumber, pointer);
}
/**
* Same as
* A DotTerminatedMessageReader is returned from which the article can be read. If the article does not exist, null is returned.
*
* You must not issue any commands to the NNTP server (i.e., call any other methods) until you finish reading the message from the returned BufferedReader
* instance. The NNTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned BufferedReader actually
* reads directly from the NNTP connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
*
* @param articleId The unique article identifier of the article to retrieve. If this parameter is null, the currently selected article is retrieved.
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of server
* deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned article
* information.
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @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 a command to the server or receiving a reply from the server.
*/
public BufferedReader retrieveArticle(final String articleId, final ArticleInfo pointer) throws IOException {
return retrieve(NNTPCommand.ARTICLE, articleId, pointer);
}
/**
* @param articleId The unique article identifier of the article to retrieve
* @param pointer A parameter through which to return the article's number and unique id
* @deprecated 3.0 use {@link #retrieveArticle(String, ArticleInfo)} instead
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @throws IOException on error
*/
@Deprecated
public Reader retrieveArticle(final String articleId, final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final Reader rdr = retrieveArticle(articleId, ai);
ai2ap(ai, pointer);
return rdr;
}
/**
* Same as
* A DotTerminatedMessageReader is returned from which the article can be read. If the article does not exist, null is returned.
*
* You must not issue any commands to the NNTP server (i.e., call any other methods) until you finish reading the message from the returned BufferedReader
* instance. The NNTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned BufferedReader actually
* reads directly from the NNTP connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
*
* @param articleNumber The number of the the article whose body is being retrieved.
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of
* server deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned
* article information.
* @return A DotTerminatedMessageReader instance from which the article body can be read. null if the article does not exist.
* @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 a command to the server or receiving a reply from the server.
*/
public BufferedReader retrieveArticleBody(final long articleNumber, final ArticleInfo pointer) throws IOException {
return retrieve(NNTPCommand.BODY, articleNumber, pointer);
}
/**
* Same as
* A DotTerminatedMessageReader is returned from which the article can be read. If the article does not exist, null is returned.
*
* You must not issue any commands to the NNTP server (i.e., call any other methods) until you finish reading the message from the returned BufferedReader
* instance. The NNTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned BufferedReader actually
* reads directly from the NNTP connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
*
* @param articleId The unique article identifier of the article whose body is being retrieved. If this parameter is null, the body of the currently
* selected article is retrieved.
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of server
* deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned article
* information.
* @return A DotTerminatedMessageReader instance from which the article body can be read. null if the article does not exist.
* @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 a command to the server or receiving a reply from the server.
*/
public BufferedReader retrieveArticleBody(final String articleId, final ArticleInfo pointer) throws IOException {
return retrieve(NNTPCommand.BODY, articleId, pointer);
}
/**
* @param articleId The unique article identifier of the article to retrieve
* @param pointer A parameter through which to return the article's number and unique id
* @return A DotTerminatedMessageReader instance from which the article body can be read. null if the article does not exist.
* @throws IOException on error
* @deprecated 3.0 use {@link #retrieveArticleBody(String, ArticleInfo)} instead
*/
@Deprecated
public Reader retrieveArticleBody(final String articleId, final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final Reader rdr = retrieveArticleBody(articleId, ai);
ai2ap(ai, pointer);
return rdr;
}
/**
* Same as
* A DotTerminatedMessageReader is returned from which the article can be read. If the article does not exist, null is returned.
*
* You must not issue any commands to the NNTP server (i.e., call any other methods) until you finish reading the message from the returned BufferedReader
* instance. The NNTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned BufferedReader actually
* reads directly from the NNTP connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
*
* @param articleNumber The number of the the article whose header is being retrieved.
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of
* server deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned
* article information.
* @return A DotTerminatedMessageReader instance from which the article header can be read. null if the article does not exist.
* @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 a command to the server or receiving a reply from the server.
*/
public BufferedReader retrieveArticleHeader(final long articleNumber, final ArticleInfo pointer) throws IOException {
return retrieve(NNTPCommand.HEAD, articleNumber, pointer);
}
/**
* Same as
* A DotTerminatedMessageReader is returned from which the article can be read. If the article does not exist, null is returned.
*
* You must not issue any commands to the NNTP server (i.e., call any other methods) until you finish reading the message from the returned BufferedReader
* instance. The NNTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned BufferedReader actually
* reads directly from the NNTP connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
*
* @param articleId The unique article identifier of the article whose header is being retrieved. If this parameter is null, the header of the currently
* selected article is retrieved.
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of server
* deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned article
* information.
* @return A DotTerminatedMessageReader instance from which the article header can be read. null if the article does not exist.
* @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 a command to the server or receiving a reply from the server.
*/
public BufferedReader retrieveArticleHeader(final String articleId, final ArticleInfo pointer) throws IOException {
return retrieve(NNTPCommand.HEAD, articleId, pointer);
}
/**
* @param articleId The unique article identifier of the article to retrieve
* @param pointer A parameter through which to return the article's number and unique id
* @return A DotTerminatedMessageReader instance from which the article body can be read. null if the article does not exist.
* @throws IOException on error
* @deprecated 3.0 use {@link #retrieveArticleHeader(String, ArticleInfo)} instead
*/
@Deprecated
public Reader retrieveArticleHeader(final String articleId, final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final Reader rdr = retrieveArticleHeader(articleId, ai);
ai2ap(ai, pointer);
return rdr;
}
/**
* @param lowArticleNumber to fetch
* @return a DotTerminatedReader if successful, null otherwise
* @throws IOException tba
* @deprecated 3.0 use {@link #retrieveArticleInfo(long)} instead
*/
@Deprecated
public Reader retrieveArticleInfo(final int lowArticleNumber) throws IOException {
return retrieveArticleInfo((long) lowArticleNumber);
}
/**
* @param lowArticleNumber to fetch
* @param highArticleNumber to fetch
* @return a DotTerminatedReader if successful, null otherwise
* @throws IOException on error
* @deprecated 3.0 use {@link #retrieveArticleInfo(long, long)} instead
*/
@Deprecated
public Reader retrieveArticleInfo(final int lowArticleNumber, final int highArticleNumber) throws IOException {
return retrieveArticleInfo((long) lowArticleNumber, (long) highArticleNumber);
}
/**
* Return article headers for a specified post.
*
*
* @param articleNumber the article to retrieve headers for
* @return a DotTerminatedReader if successful, null otherwise
* @throws IOException on error
*/
public BufferedReader retrieveArticleInfo(final long articleNumber) throws IOException {
return retrieveArticleInfo(Long.toString(articleNumber));
}
/**
* Return article headers for all articles between lowArticleNumber and highArticleNumber, inclusively. Uses the XOVER command.
*
*
* @param lowArticleNumber low number
* @param highArticleNumber high number
* @return a DotTerminatedReader if successful, null otherwise
* @throws IOException on error
*/
public BufferedReader retrieveArticleInfo(final long lowArticleNumber, final long highArticleNumber) throws IOException {
return retrieveArticleInfo(lowArticleNumber + "-" + highArticleNumber);
}
/**
* Private implementation of XOVER functionality.
*
* See {@link NNTP#xover} for legal agument formats. Alternatively, read RFC 2980 :-)
*
*
* @param articleRange
* @return Returns a DotTerminatedMessageReader if successful, null otherwise
* @throws IOException
*/
private BufferedReader retrieveArticleInfo(final String articleRange) throws IOException {
if (!NNTPReply.isPositiveCompletion(xover(articleRange))) {
return null;
}
return new DotTerminatedMessageReader(_reader_);
}
/**
* @param a tba
* @param b tba
* @return tba
* @throws IOException tba
* @deprecated 3.0 use {@link #retrieveHeader(String, long)} instead
*/
@Deprecated
public Reader retrieveHeader(final String a, final int b) throws IOException {
return retrieveHeader(a, (long) b);
}
// DEPRECATED METHODS - for API compatibility only - DO NOT USE
// ============================================================
/**
* @param header the header
* @param lowArticleNumber to fetch
* @param highArticleNumber to fetch
* @return a DotTerminatedReader if successful, null otherwise
* @throws IOException on error
* @deprecated 3.0 use {@link #retrieveHeader(String, long, long)} instead
*/
@Deprecated
public Reader retrieveHeader(final String header, final int lowArticleNumber, final int highArticleNumber) throws IOException {
return retrieveHeader(header, (long) lowArticleNumber, (long) highArticleNumber);
}
/**
* Return an article header for a specified post.
*
*
* @param header the header to retrieve
* @param articleNumber the article to retrieve the header for
* @return a DotTerminatedReader if successful, null otherwise
* @throws IOException on error
*/
public BufferedReader retrieveHeader(final String header, final long articleNumber) throws IOException {
return retrieveHeader(header, Long.toString(articleNumber));
}
/**
* Return an article header for all articles between lowArticleNumber and highArticleNumber, inclusively.
*
*
* @param header the header
* @param lowArticleNumber to fetch
* @param highArticleNumber to fetch
* @return a DotTerminatedReader if successful, null otherwise
* @throws IOException on error
*/
public BufferedReader retrieveHeader(final String header, final long lowArticleNumber, final long highArticleNumber) throws IOException {
return retrieveHeader(header, lowArticleNumber + "-" + highArticleNumber);
}
/**
* Private implementation of XHDR functionality.
*
* See {@link NNTP#xhdr} for legal agument formats. Alternatively, read RFC 1036.
*
*
* @param header
* @param articleRange
* @return Returns a DotTerminatedMessageReader if successful, null otherwise
* @throws IOException
*/
private BufferedReader retrieveHeader(final String header, final String articleRange) throws IOException {
if (!NNTPReply.isPositiveCompletion(xhdr(header, articleRange))) {
return null;
}
return new DotTerminatedMessageReader(_reader_);
}
/***
* Same as
*
* @param articleNumber The number of the article to select from the currently selected newsgroup.
* @param pointer A parameter through which to return the article's number and unique id. Although the articleId field cannot always be trusted
* because of server deviations from RFC 977 reply formats, we haven't found a server that misformats this information in response to
* this particular command. You may set this parameter to null if you do not desire to retrieve the returned article information.
* @return True if successful, false if not.
* @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 a command to the server or receiving a reply from the server.
*/
public boolean selectArticle(final long articleNumber, final ArticleInfo pointer) throws IOException {
if (!NNTPReply.isPositiveCompletion(stat(articleNumber))) {
return false;
}
if (pointer != null) {
parseArticlePointer(getReplyString(), pointer);
}
return true;
}
/**
* Same as
*
* @param articleId The unique article identifier of the article that is being selectedd. If this parameter is null, the body of the current article is
* selected
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of server
* deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned article
* information.
* @return True if successful, false if not.
* @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 a command to the server or receiving a reply from the server.
*/
public boolean selectArticle(final String articleId, final ArticleInfo pointer) throws IOException {
if (articleId != null) {
if (!NNTPReply.isPositiveCompletion(stat(articleId))) {
return false;
}
} else if (!NNTPReply.isPositiveCompletion(stat())) {
return false;
}
if (pointer != null) {
parseArticlePointer(getReplyString(), pointer);
}
return true;
}
/**
* @param articleId The unique article identifier of the article to retrieve
* @param pointer A parameter through which to return the article's number and unique id
* @return A DotTerminatedMessageReader instance from which the article body can be read. null if the article does not exist.
* @throws IOException on error
* @deprecated 3.0 use {@link #selectArticle(String, ArticleInfo)} instead
*/
@Deprecated
public boolean selectArticle(final String articleId, final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final boolean b = selectArticle(articleId, ai);
ai2ap(ai, pointer);
return b;
}
/**
* Same as
*
* @param newsgroup The newsgroup to select.
* @param info A parameter through which the newsgroup information of the selected newsgroup contained in the server reply is returned. Set this to
* null if you do not desire this information.
* @return True if the newsgroup exists and was selected, false otherwise.
* @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 a command to the server or receiving a reply from the server.
*/
public boolean selectNewsgroup(final String newsgroup, final NewsgroupInfo info) throws IOException {
if (!NNTPReply.isPositiveCompletion(group(newsgroup))) {
return false;
}
if (info != null) {
parseGroupReply(getReplyString(), info);
}
return true;
}
/**
* Same as
*
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of server
* deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned article
* information.
* @return True if successful, false if not (e.g., there is no following article).
* @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 a command to the server or receiving a reply from the server.
*/
public boolean selectNextArticle(final ArticleInfo pointer) throws IOException {
if (!NNTPReply.isPositiveCompletion(next())) {
return false;
}
if (pointer != null) {
parseArticlePointer(getReplyString(), pointer);
}
return true;
}
/**
* @param pointer A parameter through which to return the article's number and unique id
* @return True if successful, false if not.
* @throws IOException on error
* @deprecated 3.0 use {@link #selectNextArticle(ArticleInfo)} instead
*/
@Deprecated
public boolean selectNextArticle(final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final boolean b = selectNextArticle(ai);
ai2ap(ai, pointer);
return b;
}
/**
* Same as
*
* @param pointer A parameter through which to return the article's number and unique id. The articleId field cannot always be trusted because of server
* deviations from RFC 977 reply formats. You may set this parameter to null if you do not desire to retrieve the returned article
* information.
* @return True if successful, false if not (e.g., there is no previous article).
* @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 a command to the server or receiving a reply from the server.
*/
public boolean selectPreviousArticle(final ArticleInfo pointer) throws IOException {
if (!NNTPReply.isPositiveCompletion(last())) {
return false;
}
if (pointer != null) {
parseArticlePointer(getReplyString(), pointer);
}
return true;
}
/**
* @param pointer A parameter through which to return the article's number and unique id
* @return True if successful, false if not.
* @throws IOException on error
* @deprecated 3.0 use {@link #selectPreviousArticle(ArticleInfo)} instead
*/
@Deprecated
public boolean selectPreviousArticle(final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final boolean b = selectPreviousArticle(ai);
ai2ap(ai, pointer);
return b;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/NNTPCommand.java 0000664 0000000 0000000 00000004520 14340477222 0031612 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* NNTPCommand stores a set of constants for NNTP command codes. To interpret the meaning of the codes, familiarity with RFC 977 is assumed.
*/
public final class NNTPCommand {
public static final int ARTICLE = 0;
public static final int BODY = 1;
public static final int GROUP = 2;
public static final int HEAD = 3;
public static final int HELP = 4;
public static final int IHAVE = 5;
public static final int LAST = 6;
public static final int LIST = 7;
public static final int NEWGROUPS = 8;
public static final int NEWNEWS = 9;
public static final int NEXT = 10;
public static final int POST = 11;
public static final int QUIT = 12;
public static final int SLAVE = 13;
public static final int STAT = 14;
public static final int AUTHINFO = 15;
public static final int XOVER = 16;
public static final int XHDR = 17;
private static final String[] commands = { "ARTICLE", "BODY", "GROUP", "HEAD", "HELP", "IHAVE", "LAST", "LIST", "NEWGROUPS", "NEWNEWS", "NEXT", "POST",
"QUIT", "SLAVE", "STAT", "AUTHINFO", "XOVER", "XHDR" };
/**
* Retrieve the NNTP protocol command string corresponding to a specified command code.
*
*
* @param command The command code.
* @return The NNTP protcol command string corresponding to a specified command code.
*/
public static String getCommand(final int command) {
return commands[command];
}
// Cannot be instantiated
private NNTPCommand() {
}
}
NNTPConnectionClosedException.java 0000664 0000000 0000000 00000003557 14340477222 0035276 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp /*
* 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.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.
* This exception is derived from IOException and therefore may be caught either as an IOException or specifically as an NNTPConnectionClosedException.
*
* @see NNTP
* @see NNTPClient
*/
public final class NNTPConnectionClosedException extends IOException {
private static final long serialVersionUID = 1029785635891040770L;
/** Constructs a NNTPConnectionClosedException with no message */
public NNTPConnectionClosedException() {
}
/**
* Constructs a NNTPConnectionClosedException with a specified message.
*
*
* @param message The message explaining the reason for the exception.
*/
public NNTPConnectionClosedException(final String message) {
super(message);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/NNTPReply.java 0000664 0000000 0000000 00000014453 14340477222 0031335 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* NNTPReply stores a set of constants for NNTP reply codes. To interpret the meaning of the codes, familiarity with RFC 977 is assumed. The mnemonic constant
* names are transcriptions from the code descriptions of RFC 977.
*/
public final class NNTPReply {
public static final int HELP_TEXT_FOLLOWS = 100;
public static final int DEBUG_OUTPUT = 199;
public static final int SERVER_READY_POSTING_ALLOWED = 200;
public static final int SERVER_READY_POSTING_NOT_ALLOWED = 201;
public static final int SLAVE_STATUS_NOTED = 202;
public static final int CLOSING_CONNECTION = 205;
public static final int GROUP_SELECTED = 211;
public static final int ARTICLE_RETRIEVED_HEAD_AND_BODY_FOLLOW = 220;
public static final int ARTICLE_RETRIEVED_HEAD_FOLLOWS = 221;
public static final int ARTICLE_RETRIEVED_BODY_FOLLOWS = 222;
public static final int ARTICLE_RETRIEVED_REQUEST_TEXT_SEPARATELY = 223;
public static final int ARTICLE_LIST_BY_MESSAGE_ID_FOLLOWS = 230;
public static final int NEW_NEWSGROUP_LIST_FOLLOWS = 231;
public static final int ARTICLE_TRANSFERRED_OK = 235;
public static final int ARTICLE_POSTED_OK = 240;
public static final int AUTHENTICATION_ACCEPTED = 281;
public static final int SEND_ARTICLE_TO_TRANSFER = 335;
public static final int SEND_ARTICLE_TO_POST = 340;
public static final int MORE_AUTH_INFO_REQUIRED = 381;
public static final int SERVICE_DISCONTINUED = 400;
public static final int NO_SUCH_NEWSGROUP = 411;
public static final int NO_NEWSGROUP_SELECTED = 412;
public static final int NO_CURRENT_ARTICLE_SELECTED = 420;
public static final int NO_NEXT_ARTICLE = 421;
public static final int NO_PREVIOUS_ARTICLE = 422;
public static final int NO_SUCH_ARTICLE_NUMBER = 423;
public static final int NO_SUCH_ARTICLE_FOUND = 430;
public static final int ARTICLE_NOT_WANTED = 435;
public static final int TRANSFER_FAILED = 436;
public static final int ARTICLE_REJECTED = 437;
public static final int POSTING_NOT_ALLOWED = 440;
public static final int POSTING_FAILED = 441;
/** @since 2.2 - corrected value to 480 */
public static final int AUTHENTICATION_REQUIRED = 480;
public static final int AUTHENTICATION_REJECTED = 482;
public static final int COMMAND_NOT_RECOGNIZED = 500;
public static final int COMMAND_SYNTAX_ERROR = 501;
public static final int PERMISSION_DENIED = 502;
public static final int PROGRAM_FAULT = 503;
// Cannot be instantiated
/**
* Determine if a reply code is an informational response. All codes beginning with a 1 are positive informational responses. Informational responses are
* used to provide human readable information such as help text.
*
*
* @param reply The reply code to test.
* @return True if a reply code is an informational response, false if not.
*/
public static boolean isInformational(final int reply) {
return reply >= 100 && reply < 200;
}
/**
* Determine if a reply code is a negative permanent response. All codes beginning with a 5 are negative permanent responses. The NNTP server will send a
* negative permanent response when it does not implement a command, a command is incorrectly formatted, or a serious program error occurs.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a negative permanent response, false if not.
*/
public static boolean isNegativePermanent(final int reply) {
return reply >= 500 && reply < 600;
}
/**
* Determine if a reply code is a negative transient response. All codes beginning with a 4 are negative transient responses. The NNTP server will send a
* negative transient response on the failure of a correctly formatted command that could not be performed for some reason. For example, retrieving an
* article that does not exist will result in a negative transient response.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a negative transient response, false if not.
*/
public static boolean isNegativeTransient(final int reply) {
return reply >= 400 && reply < 500;
}
/**
* Determine if a reply code is a positive completion response. All codes beginning with a 2 are positive completion responses. The NNTP server will send a
* positive completion response on the final successful completion of a command.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a positive completion response, false if not.
*/
public static boolean isPositiveCompletion(final int reply) {
return reply >= 200 && reply < 300;
}
/**
* Determine if a reply code is a positive intermediate response. All codes beginning with a 3 are positive intermediate responses. The NNTP server will
* send a positive intermediate response on the successful completion of one part of a multi-part command or sequence of commands. For example, after a
* successful POST command, a positive intermediate response will be sent to indicate that the server is ready to receive the article to be posted.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a positive intermediate response, false if not.
*/
public static boolean isPositiveIntermediate(final int reply) {
return reply >= 300 && reply < 400;
}
private NNTPReply() {
}
}
NewGroupsOrNewsQuery.java 0000664 0000000 0000000 00000020036 14340477222 0033572 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp /*
* 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.util.Calendar;
/**
* 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
* } respectively. It prevents you from having to format date, time, distribution, and newgroup arguments.
*
* You might use the class as follows:
*
*
*
* @param date The date since which new groups or news have arrived.
* @param gmt True if the date should be considered as GMT, false if not.
*/
public NewGroupsOrNewsQuery(final Calendar date, final boolean gmt) {
int num;
String str;
final StringBuilder buffer;
this.distributions = null;
this.newsgroups = null;
this.isGMT = gmt;
buffer = new StringBuilder();
// Get year
num = date.get(Calendar.YEAR);
str = Integer.toString(num);
num = str.length();
if (num >= 2) {
buffer.append(str.substring(num - 2));
} else {
buffer.append("00");
}
// Get month
num = date.get(Calendar.MONTH) + 1;
str = Integer.toString(num);
num = str.length();
if (num == 1) {
buffer.append('0');
buffer.append(str);
} else if (num == 2) {
buffer.append(str);
} else {
buffer.append("01");
}
// Get day
num = date.get(Calendar.DAY_OF_MONTH);
str = Integer.toString(num);
num = str.length();
if (num == 1) {
buffer.append('0');
buffer.append(str);
} else if (num == 2) {
buffer.append(str);
} else {
buffer.append("01");
}
this.date = buffer.toString();
buffer.setLength(0);
// Get hour
num = date.get(Calendar.HOUR_OF_DAY);
str = Integer.toString(num);
num = str.length();
if (num == 1) {
buffer.append('0');
buffer.append(str);
} else if (num == 2) {
buffer.append(str);
} else {
buffer.append("00");
}
// Get minutes
num = date.get(Calendar.MINUTE);
str = Integer.toString(num);
num = str.length();
if (num == 1) {
buffer.append('0');
buffer.append(str);
} else if (num == 2) {
buffer.append(str);
} else {
buffer.append("00");
}
// Get seconds
num = date.get(Calendar.SECOND);
str = Integer.toString(num);
num = str.length();
if (num == 1) {
buffer.append('0');
buffer.append(str);
} else if (num == 2) {
buffer.append(str);
} else {
buffer.append("00");
}
this.time = buffer.toString();
}
/**
* Add a distribution group to the query. The distribution part of a newsgroup is the segment of the name preceding the first dot (e.g., comp, alt, rec).
* Only those newsgroups matching one of the distributions or, in the case of NEWNEWS, an article in a newsgroup matching one of the distributions, will be
* reported as a query result. Adding distributions is purely optional.
*
*
* @param distribution A distribution to add to the query.
*/
public void addDistribution(final String distribution) {
if (distributions != null) {
distributions.append(',');
} else {
distributions = new StringBuffer();
}
distributions.append(distribution);
}
/**
* Add a newsgroup to the list of newsgroups being queried. Newsgroups added this way are only meaningful to the NEWNEWS command. Newsgroup names may
* include the
*
* @param newsgroup The newsgroup to add to the list of groups to be checked for new news.
*/
public void addNewsgroup(final String newsgroup) {
if (newsgroups != null) {
newsgroups.append(',');
} else {
newsgroups = new StringBuffer();
}
newsgroups.append(newsgroup);
}
/**
* Return the NNTP query formatted date (year, month, day in the form YYMMDD.
*
*
* @return The NNTP query formatted date.
*/
public String getDate() {
return date;
}
/**
* Return the comma separated list of distributions. This may be null if there are no distributions.
*
*
* @return The list of distributions, which may be null if no distributions have been specified.
*/
public String getDistributions() {
return distributions == null ? null : distributions.toString();
}
/**
* Return the comma separated list of newsgroups. This may be null if there are no newsgroups
*
*
* @return The list of newsgroups, which may be null if no newsgroups have been specified.
*/
public String getNewsgroups() {
return newsgroups == null ? null : newsgroups.toString();
}
/**
* Return the NNTP query formatted time (hour, minutes, seconds in the form HHMMSS.
*
*
* @return The NNTP query formatted time.
*/
public String getTime() {
return time;
}
/**
* Return whether or not the query date should be treated as GMT.
*
*
* @return True if the query date is to be treated as GMT, false if not.
*/
public boolean isGMT() {
return isGMT;
}
/**
* Add a newsgroup to the list of newsgroups being queried, but indicate that group should not be checked for new news. Newsgroups added this way are only
* meaningful to the NEWNEWS command. Newsgroup names may include the
* The following would create a query that searched for new news in all comp.lang.java newsgroups except for comp.lang.java.advocacy.
*
*
*
* @param newsgroup The newsgroup to add to the list of groups to be checked for new news, but which should be omitted from the search for new news..
*/
public void omitNewsgroup(final String newsgroup) {
addNewsgroup("!" + newsgroup);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/NewsgroupInfo.java 0000664 0000000 0000000 00000011156 14340477222 0032344 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* 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.
*
* @see NNTPClient
*/
public final class NewsgroupInfo {
/**
* A constant indicating that the posting permission of a newsgroup is unknown. For example, the NNTP GROUP command does not return posting information, so
* NewsgroupInfo instances obtained from that command willhave an UNKNOWN_POSTING_PERMISSION.
*/
public static final int UNKNOWN_POSTING_PERMISSION = 0;
/** A constant indicating that a newsgroup is moderated. */
public static final int MODERATED_POSTING_PERMISSION = 1;
/** A constant indicating that a newsgroup is public and unmoderated. */
public static final int PERMITTED_POSTING_PERMISSION = 2;
/**
* A constant indicating that a newsgroup is closed for general posting.
*/
public static final int PROHIBITED_POSTING_PERMISSION = 3;
private String newsgroup;
private long estimatedArticleCount;
private long firstArticle;
private long lastArticle;
private int postingPermission;
@Deprecated
public int getArticleCount() {
return (int) estimatedArticleCount;
}
/**
* Get the estimated number of articles in the newsgroup. The accuracy of this value will depend on the server implementation.
*
*
* @return The estimated number of articles in the newsgroup.
*/
public long getArticleCountLong() {
return estimatedArticleCount;
}
@Deprecated
public int getFirstArticle() {
return (int) firstArticle;
}
/**
* Get the number of the first article in the newsgroup.
*
*
* @return The number of the first article in the newsgroup.
*/
public long getFirstArticleLong() {
return firstArticle;
}
@Deprecated
public int getLastArticle() {
return (int) lastArticle;
}
/**
* Get the number of the last article in the newsgroup.
*
*
* @return The number of the last article in the newsgroup.
*/
public long getLastArticleLong() {
return lastArticle;
}
/**
* Get the newsgroup name.
*
*
* @return The name of the newsgroup.
*/
public String getNewsgroup() {
return newsgroup;
}
/**
* Get the posting permission of the newsgroup. This will be one of the
*
* @return The posting permission status of the newsgroup.
*/
public int getPostingPermission() {
return postingPermission;
}
void setArticleCount(final long count) {
estimatedArticleCount = count;
}
void setFirstArticle(final long first) {
firstArticle = first;
}
/*
* public String toString() { StringBuilder buffer = new StringBuilder(); buffer.append(__newsgroup); buffer.append(' '); buffer.append(__lastArticle);
* buffer.append(' '); buffer.append(__firstArticle); buffer.append(' '); switch(__postingPermission) { case 1: buffer.append('m'); break; case 2:
* buffer.append('y'); break; case 3: buffer.append('n'); break; } return buffer.toString(); }
*/
// DEPRECATED METHODS - for API compatibility only - DO NOT USE
void setLastArticle(final long last) {
lastArticle = last;
}
void setNewsgroup(final String newsgroup) {
this.newsgroup = newsgroup;
}
void setPostingPermission(final int permission) {
postingPermission = permission;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/NewsgroupIterator.java 0000664 0000000 0000000 00000003316 14340477222 0033241 0 ustar 00root root 0000000 0000000 /*
* 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.util.Iterator;
/**
* Class which wraps an {@code Iterable
* The main purpose of the class is to faciliatate the article posting process, by relieving the programmer from having to explicitly format an article header.
* For example:
*
*
*
* @param from The value of the
*
* @param headerField The header field to add, not including the colon.
* @param value The value of the added header field.
*/
public void addHeaderField(final String headerField, final String value) {
headerFields.append(headerField);
headerFields.append(": ");
headerFields.append(value);
headerFields.append('\n');
}
/**
* Adds a newsgroup to the article
*
* @param newsgroup The newsgroup to add to the article's newsgroup distribution list.
*/
public void addNewsgroup(final String newsgroup) {
if (newsgroupCount++ > 0) {
newsgroups.append(',');
}
newsgroups.append(newsgroup);
}
/**
* Returns the address used in the
*
* @return The from address.
*/
public String getFromAddress() {
return from;
}
/**
* Returns the contents of the
*
* @return The comma-separated list of newsgroups to which the article is being posted.
*/
public String getNewsgroups() {
return newsgroups.toString();
}
/**
* Returns the subject used in the
*
* @return The subject.
*/
public String getSubject() {
return subject;
}
/**
* Converts the SimpleNNTPHeader to a properly formatted header in the form of a String, including the blank line used to separate the header from the
* article body.
*
*
* @return The article header in the form of a String.
*/
@Override
public String toString() {
final StringBuilder header = new StringBuilder();
header.append("From: ");
header.append(from);
header.append("\nNewsgroups: ");
header.append(newsgroups.toString());
header.append("\nSubject: ");
header.append(subject);
header.append('\n');
if (headerFields.length() > 0) {
header.append(headerFields.toString());
}
header.append('\n');
return header.toString();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/ThreadContainer.java 0000664 0000000 0000000 00000006050 14340477222 0032606 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* A placeholder utility class, used for constructing a tree of Threadables Original implementation by Jamie Zawinski. See the Grendel source for more details
* here Threadable objects
*/
class ThreadContainer {
Threadable threadable;
ThreadContainer parent;
// ThreadContainer prev;
ThreadContainer next;
ThreadContainer child;
/**
*
* @param target
* @return true if child is under self's tree. Detects circular references
*/
boolean findChild(final ThreadContainer target) {
if (child == null) {
return false;
}
if (child == target) {
return true;
}
return child.findChild(target);
}
// Copy the ThreadContainer tree structure down into the underlying Threadable objects
// (Make the Threadable tree look like the ThreadContainer tree)
// TODO convert this to an iterative function - this can blow the stack
// with very large Threadable trees
void flush() {
if (parent != null && threadable == null) {
throw new RuntimeException("no threadable in " + this.toString());
}
parent = null;
if (threadable != null) {
threadable.setChild(child == null ? null : child.threadable);
}
if (child != null) {
child.flush();
child = null;
}
if (threadable != null) {
threadable.setNext(next == null ? null : next.threadable);
}
if (next != null) {
next.flush();
next = null;
}
threadable = null;
}
/**
* Reverse the entire set of children
*
*/
void reverseChildren() {
if (child != null) {
ThreadContainer kid, prev, rest;
for (prev = null, kid = child, rest = kid.next; kid != null; prev = kid, kid = rest, rest = rest == null ? null : rest.next) {
kid.next = prev;
}
child = prev;
// Do it for the kids
for (kid = child; kid != null; kid = kid.next) {
kid.reverseChildren();
}
}
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/Threadable.java 0000664 0000000 0000000 00000002343 14340477222 0031570 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* A placeholder interface for threadable message objects Author: Rory Winston (rwinston@checkfree.com)
*
*/
public interface Threadable {
boolean isDummy();
Threadable makeDummy();
String messageThreadId();
String[] messageThreadReferences();
void setChild(Threadable child);
void setNext(Threadable next);
String simplifiedSubject();
boolean subjectIsReply();
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/nntp/Threader.java 0000664 0000000 0000000 00000040456 14340477222 0031302 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* This is an implementation of a message threading algorithm, as originally devised by Zamie Zawinski.
* See http://www.jwz.org/doc/threading.html for details.
* For his Java implementation, see
*
* http://lxr.mozilla.org/mozilla/source/grendel/sources/grendel/view/Threader.java
*/
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Threader {
/**
*
* @param threadable
* @param idTable
*/
private void buildContainer(final Threadable threadable, final HashMap
*
* @param host The address of the server.
* @return The time value retrieved from the server.
* @throws IOException If an error occurs while retrieving the time.
*/
public TimeInfo getTime(final InetAddress host) throws IOException {
return getTime(host, NtpV3Packet.NTP_PORT);
}
/**
* Retrieves the time information from the specified server and port and returns it. The time is the number of miliiseconds since 00:00 (midnight) 1 January
* 1900 UTC, as specified by RFC 1305. This method reads the raw NTP packet and constructs a TimeInfo object that allows access to all the fields of
* the NTP message header.
*
*
* @param host The address of the server.
* @param port The port of the service.
* @return The time value retrieved from the server.
* @throws IOException If an error occurs while retrieving the time or if received packet does not match the request.
*/
public TimeInfo getTime(final InetAddress host, final int port) throws IOException {
// if not connected then open to next available UDP port
if (!isOpen()) {
open();
}
final NtpV3Packet message = new NtpV3Impl();
message.setMode(NtpV3Packet.MODE_CLIENT);
message.setVersion(version);
final DatagramPacket sendPacket = message.getDatagramPacket();
sendPacket.setAddress(host);
sendPacket.setPort(port);
final NtpV3Packet recMessage = new NtpV3Impl();
final DatagramPacket receivePacket = recMessage.getDatagramPacket();
/*
* Must minimize the time between getting the current time, timestamping the packet, and sending it out which introduces an error in the delay time. No
* extraneous logging and initializations here !!!
*/
final TimeStamp now = TimeStamp.getCurrentTime();
// Note that if you do not set the transmit time field then originating time
// in server response is all 0's which is "Thu Feb 07 01:28:16 EST 2036".
message.setTransmitTime(now);
_socket_.send(sendPacket);
_socket_.receive(receivePacket);
final long returnTimeMillis = System.currentTimeMillis();
// Prevent invalid time information if response does not match request
if (!now.equals(recMessage.getOriginateTimeStamp())) {
throw new IOException("Originate time does not match the request");
}
// create TimeInfo message container but don't pre-compute the details yet
return new TimeInfo(recMessage, returnTimeMillis, false);
}
/**
* Returns the NTP protocol version number that client sets on request packet that is sent to remote host (e.g. 3=NTP v3, 4=NTP v4, etc.)
*
* @return the NTP protocol version number that client sets on request packet.
* @see #setVersion(int)
*/
public int getVersion() {
return version;
}
/**
* Sets the NTP protocol version number that client sets on request packet communicate with remote host.
*
* @param version the NTP protocol version number
*/
public void setVersion(final int version) {
this.version = version;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ntp/NtpUtils.java 0000664 0000000 0000000 00000007267 14340477222 0031153 0 ustar 00root root 0000000 0000000 /*
* 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.ntp;
/**
* Common NtpUtils Helper class.
*
*/
public final class NtpUtils {
/**
* Returns 32-bit integer address to IPv4 address string "%d.%d.%d.%d" format.
*
* @param address the 32-bit address
* @return the raw IP address in a string format.
*/
public static String getHostAddress(final int address) {
return ((address >>> 24) & 0xFF) + "." + ((address >>> 16) & 0xFF) + "." + ((address >>> 8) & 0xFF) + "." + ((address >>> 0) & 0xFF);
}
/**
* Return human-readable name of message mode type (RFC 1305).
*
* @param mode the mode type
* @return mode name
*/
public static String getModeName(final int mode) {
switch (mode) {
case NtpV3Packet.MODE_RESERVED:
return "Reserved";
case NtpV3Packet.MODE_SYMMETRIC_ACTIVE:
return "Symmetric Active";
case NtpV3Packet.MODE_SYMMETRIC_PASSIVE:
return "Symmetric Passive";
case NtpV3Packet.MODE_CLIENT:
return "Client";
case NtpV3Packet.MODE_SERVER:
return "Server";
case NtpV3Packet.MODE_BROADCAST:
return "Broadcast";
case NtpV3Packet.MODE_CONTROL_MESSAGE:
return "Control";
case NtpV3Packet.MODE_PRIVATE:
return "Private";
default:
return "Unknown";
}
}
/**
* Returns NTP packet reference identifier as IP address.
*
* @param packet NTP packet
* @return the packet reference id (as IP address) in "%d.%d.%d.%d" format.
*/
public static String getRefAddress(final NtpV3Packet packet) {
final int address = (packet == null) ? 0 : packet.getReferenceId();
return getHostAddress(address);
}
/**
* Get refId as reference clock string (e.g. GPS, WWV, LCL). If string is invalid (non-ASCII character) then returns empty string "". For details refer to
* the Comprehensive List of Clock Drivers.
*
* @param message the message to check
* @return reference clock string if primary NTP server
*/
public static String getReferenceClock(final NtpV3Packet message) {
if (message == null) {
return "";
}
final int refId = message.getReferenceId();
if (refId == 0) {
return "";
}
final StringBuilder buf = new StringBuilder(4);
// start at highest-order byte (0x4c434c00 -> LCL)
for (int shiftBits = 24; shiftBits >= 0; shiftBits -= 8) {
final char c = (char) ((refId >>> shiftBits) & 0xff);
if (c == 0) { // 0-terminated ASCII string
break;
}
if (!Character.isLetterOrDigit(c)) {
return "";
}
buf.append(c);
}
return buf.toString();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ntp/NtpV3Impl.java 0000664 0000000 0000000 00000044265 14340477222 0031164 0 ustar 00root root 0000000 0000000 /*
* 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.ntp;
import java.net.DatagramPacket;
/**
* Implementation of NtpV3Packet with methods converting Java objects to/from the Network Time Protocol (NTP) data message header format described in RFC-1305.
*
*/
public class NtpV3Impl implements NtpV3Packet {
private static final int MODE_INDEX = 0;
private static final int MODE_SHIFT = 0;
private static final int VERSION_INDEX = 0;
private static final int VERSION_SHIFT = 3;
private static final int LI_INDEX = 0;
private static final int LI_SHIFT = 6;
private static final int STRATUM_INDEX = 1;
private static final int POLL_INDEX = 2;
private static final int PRECISION_INDEX = 3;
private static final int ROOT_DELAY_INDEX = 4;
private static final int ROOT_DISPERSION_INDEX = 8;
private static final int REFERENCE_ID_INDEX = 12;
private static final int REFERENCE_TIMESTAMP_INDEX = 16;
private static final int ORIGINATE_TIMESTAMP_INDEX = 24;
private static final int RECEIVE_TIMESTAMP_INDEX = 32;
private static final int TRANSMIT_TIMESTAMP_INDEX = 40;
// private static final int KEY_IDENTIFIER_INDEX = 48;
// private static final int MESSAGE_DIGEST = 54; /* len 16 bytes */
/**
* Convert byte to unsigned integer. Java only has signed types so we have to do more work to get unsigned ops.
*
* @param b input byte
* @return unsigned int value of byte
*/
protected static final int ui(final byte b) {
final int i = b & 0xFF;
return i;
}
/**
* Convert byte to unsigned long. Java only has signed types so we have to do more work to get unsigned ops
*
* @param b input byte
* @return unsigned long value of byte
*/
protected static final long ul(final byte b) {
final long i = b & 0xFF;
return i;
}
private final byte[] buf = new byte[48];
private volatile DatagramPacket dp;
/** Creates a new instance of NtpV3Impl */
public NtpV3Impl() {
}
/**
* Compares this object against the specified object. The result is
* Methods exist to convert NTP timestamps to and from the equivalent Java date representation, which is the number of milliseconds since the standard base time
* known as "the epoch", namely January 1, 1970, 00:00:00 GMT.
*
*
* @param method the {@link AUTH_METHOD} to use
* @param username the user name
* @param password the password
* @return True if successfully completed, false if not.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @throws NoSuchAlgorithmException If the CRAM hash algorithm cannot be instantiated by the Java runtime system.
* @throws InvalidKeyException If the CRAM hash algorithm failed to use the given password.
* @throws InvalidKeySpecException If the CRAM hash algorithm failed to use the given password.
*/
public boolean auth(final AUTH_METHOD method, final String username, final String password)
throws IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidKeySpecException {
if (sendCommand(POP3Command.AUTH, method.getAuthName()) != POP3Reply.OK_INT) {
return false;
}
switch (method) {
case PLAIN:
// the server sends an empty response ("+ "), so we don't have to read it.
return sendCommand(new String(Base64.encodeBase64(("\000" + username + "\000" + password).getBytes(getCharset())), getCharset())) == POP3Reply.OK;
case CRAM_MD5:
// get the CRAM challenge
final byte[] serverChallenge = Base64.decodeBase64(getReplyString().substring(2).trim());
// get the Mac instance
final Mac hmac_md5 = Mac.getInstance("HmacMD5");
hmac_md5.init(new SecretKeySpec(password.getBytes(getCharset()), "HmacMD5"));
// compute the result:
final byte[] hmacResult = convertToHexString(hmac_md5.doFinal(serverChallenge)).getBytes(getCharset());
// join the byte arrays to form the reply
final byte[] usernameBytes = username.getBytes(getCharset());
final byte[] toEncode = new byte[usernameBytes.length + 1 /* the space */ + hmacResult.length];
System.arraycopy(usernameBytes, 0, toEncode, 0, usernameBytes.length);
toEncode[usernameBytes.length] = ' ';
System.arraycopy(hmacResult, 0, toEncode, usernameBytes.length + 1, hmacResult.length);
// send the reply and read the server code:
return sendCommand(Base64.encodeBase64StringUnChunked(toEncode)) == POP3Reply.OK;
default:
return false;
}
}
/**
* Converts the given byte array to a String containing the hex values of the bytes. For example, the byte 'A' will be converted to '41', because this is
* the ASCII code (and the byte value) of the capital letter 'A'.
*
* @param a The byte array to convert.
* @return The resulting String of hex codes.
*/
private String convertToHexString(final byte[] a) {
final StringBuilder result = new StringBuilder(a.length * 2);
for (final byte element : a) {
if ((element & 0x0FF) <= 15) {
result.append("0");
}
result.append(Integer.toHexString(element & 0x0FF));
}
return result.toString();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/POP3.java 0000664 0000000 0000000 00000026166 14340477222 0030171 0 ustar 00root root 0000000 0000000 /*
* 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.pop3;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
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;
import org.apache.commons.net.util.NetConstants;
/**
* The POP3 class is not meant to be used by itself and is provided only so that you may easily implement your own POP3 client if you so desire. If you have no
* need to perform your own implementation, you should use {@link org.apache.commons.net.pop3.POP3Client}.
*
* 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 POP3Client
* @see org.apache.commons.net.MalformedServerReplyException
*/
public class POP3 extends SocketClient {
/** The default POP3 port. Set to 110 according to RFC 1288. */
public static final int DEFAULT_PORT = 110;
/**
* A constant representing the state where the client is not yet connected to a POP3 server.
*/
public static final int DISCONNECTED_STATE = -1;
/** A constant representing the POP3 authorization state. */
public static final int AUTHORIZATION_STATE = 0;
/** A constant representing the POP3 transaction state. */
public static final int TRANSACTION_STATE = 1;
/** A constant representing the POP3 update state. */
public static final int UPDATE_STATE = 2;
static final String OK = "+OK";
// The reply indicating intermediate response to a command.
static final String OK_INT = "+ ";
static final String ERROR = "-ERR";
// 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.
static final Charset DEFAULT_ENCODING = StandardCharsets.ISO_8859_1;
private int popState;
BufferedWriter writer;
BufferedReader reader;
int replyCode;
String lastReplyLine;
List
* 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 POP3MessageInfo
* @see org.apache.commons.net.io.DotTerminatedMessageReader
* @see org.apache.commons.net.MalformedServerReplyException
*/
public class POP3Client extends POP3 {
private static POP3MessageInfo parseStatus(final String line) {
int num, size;
final StringTokenizer tokenizer;
tokenizer = new StringTokenizer(line);
if (!tokenizer.hasMoreElements()) {
return null;
}
num = size = 0;
try {
num = Integer.parseInt(tokenizer.nextToken());
if (!tokenizer.hasMoreElements()) {
return null;
}
size = Integer.parseInt(tokenizer.nextToken());
} catch (final NumberFormatException e) {
return null;
}
return new POP3MessageInfo(num, size);
}
private static POP3MessageInfo parseUID(String line) {
int num;
final StringTokenizer tokenizer;
tokenizer = new StringTokenizer(line);
if (!tokenizer.hasMoreElements()) {
return null;
}
num = 0;
try {
num = Integer.parseInt(tokenizer.nextToken());
if (!tokenizer.hasMoreElements()) {
return null;
}
line = tokenizer.nextToken();
} catch (final NumberFormatException e) {
return null;
}
return new POP3MessageInfo(num, line);
}
/**
* Send a CAPA command to the POP3 server.
*
* @return True if the command was successful, false if not.
* @throws IOException If a network I/O error occurs in the process of sending the CAPA command.
* @since 3.1 (was previously in ExtendedPOP3Client)
*/
public boolean capa() throws IOException {
if (sendCommand(POP3Command.CAPA) == POP3Reply.OK) {
getAdditionalReply();
return true;
}
return false;
}
/**
* Delete a message from the POP3 server. The message is only marked for deletion by the server. If you decide to unmark the message, you must issuse a
* {@link #reset reset } command. Messages marked for deletion are only deleted by the server on {@link #logout logout }. A delete attempt can only succeed
* if the client is in the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE TRANSACTION_STATE } .
*
* @param messageId The message number to delete.
* @return True if the deletion attempt was successful, false if not.
* @throws IOException If a network I/O error occurs in the process of sending the delete command.
*/
public boolean deleteMessage(final int messageId) throws IOException {
if (getState() == TRANSACTION_STATE) {
return sendCommand(POP3Command.DELE, Integer.toString(messageId)) == POP3Reply.OK;
}
return false;
}
/**
* List an individual message. A list attempt can only succeed if the client is in the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
* TRANSACTION_STATE } . Returns a POP3MessageInfo instance containing the number of the listed message and the size of the message in bytes. Returns null
* if the list attempt fails (e.g., if the specified message number does not exist).
*
* @param messageId The number of the message list.
* @return A POP3MessageInfo instance containing the number of the listed message and the size of the message in bytes. Returns null if the list attempt
* fails.
* @throws IOException If a network I/O error occurs in the process of sending the list command.
*/
public POP3MessageInfo listMessage(final int messageId) throws IOException {
if (getState() != TRANSACTION_STATE) {
return null;
}
if (sendCommand(POP3Command.LIST, Integer.toString(messageId)) != POP3Reply.OK) {
return null;
}
return parseStatus(lastReplyLine.substring(3));
}
/**
* List all messages. A list attempt can only succeed if the client is in the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE TRANSACTION_STATE }
* . Returns an array of POP3MessageInfo instances, each containing the number of a message and its size in bytes. If there are no messages, this method
* returns a zero length array. If the list attempt fails, it returns null.
*
* @return An array of POP3MessageInfo instances representing all messages in the order they appear in the mailbox, each containing the number of a message
* and its size in bytes. If there are no messages, this method returns a zero length array. If the list attempt fails, it returns null.
* @throws IOException If a network I/O error occurs in the process of sending the list command.
*/
public POP3MessageInfo[] listMessages() throws IOException {
if (getState() != TRANSACTION_STATE) {
return null;
}
if (sendCommand(POP3Command.LIST) != POP3Reply.OK) {
return null;
}
getAdditionalReply();
// This could be a zero length array if no messages present
final POP3MessageInfo[] messages = new POP3MessageInfo[replyLines.size() - 2]; // skip first and last lines
final ListIterator
* You must first connect to the server with {@link org.apache.commons.net.SocketClient#connect connect } before attempting to login. 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 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.
*
* @param username The account name being logged in to.
* @param timestamp The timestamp string to combine with the secret.
* @param secret The shared secret which produces the MD5 digest when combined with the timestamp.
* @return True if the login attempt was successful, false if not.
* @throws IOException If a network I/O error occurs in the process of logging in.
* @throws NoSuchAlgorithmException If the MD5 encryption algorithm cannot be instantiated by the Java runtime system.
*/
public boolean login(final String username, String timestamp, final String secret) throws IOException, NoSuchAlgorithmException {
int i;
final byte[] digest;
final StringBuilder buffer;
final StringBuilder digestBuffer;
final MessageDigest md5;
if (getState() != AUTHORIZATION_STATE) {
return false;
}
md5 = MessageDigest.getInstance("MD5");
timestamp += secret;
digest = md5.digest(timestamp.getBytes(getCharset()));
digestBuffer = new StringBuilder(128);
for (i = 0; i < digest.length; i++) {
final int digit = digest[i] & 0xff;
if (digit <= 15) { // Add leading zero if necessary (NET-351)
digestBuffer.append("0");
}
digestBuffer.append(Integer.toHexString(digit));
}
buffer = new StringBuilder(256);
buffer.append(username);
buffer.append(' ');
buffer.append(digestBuffer.toString());
if (sendCommand(POP3Command.APOP, buffer.toString()) != POP3Reply.OK) {
return false;
}
setState(TRANSACTION_STATE);
return true;
}
/**
* 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.
*
* @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.
*/
public boolean logout() throws IOException {
if (getState() == TRANSACTION_STATE) {
setState(UPDATE_STATE);
}
sendCommand(POP3Command.QUIT);
return replyCode == POP3Reply.OK;
}
/**
* Send a NOOP command to the POP3 server. This is useful for keeping a connection alive since most POP3 servers will timeout 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 } .
*
* @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.
*/
public boolean noop() throws IOException {
if (getState() == TRANSACTION_STATE) {
return sendCommand(POP3Command.NOOP) == POP3Reply.OK;
}
return false;
}
/**
* 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 } .
*
* @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.
*/
public boolean reset() throws IOException {
if (getState() == TRANSACTION_STATE) {
return sendCommand(POP3Command.RSET) == POP3Reply.OK;
}
return false;
}
/**
* 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 }
*
* 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
* reads directly from the POP3 connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
* @param messageId The number of the message to fetch.
* @return A DotTerminatedMessageReader instance from which the entire message can be read. This can safely be cast to a {@link java.io.BufferedReader
* BufferedReader} in order to use the {@link java.io.BufferedReader#readLine() BufferedReader#readLine()} method. Returns null if the retrieval
* attempt fails (e.g., if the specified message number does not exist).
* @throws IOException If a network I/O error occurs in the process of sending the retrieve message command.
*/
public Reader retrieveMessage(final int messageId) throws IOException {
if (getState() != TRANSACTION_STATE) {
return null;
}
if (sendCommand(POP3Command.RETR, Integer.toString(messageId)) != POP3Reply.OK) {
return null;
}
return new DotTerminatedMessageReader(reader);
}
/**
* 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 }
*
* 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
* reads directly from the POP3 connection. After the end of message has been reached, new commands can be executed and their replies read. If you do not
* follow these requirements, your program will not work properly.
*
* @param messageId The number of the message to fetch.
* @param numLines The top number of lines to fetch. This must be >= 0.
* @return A DotTerminatedMessageReader instance from which the specified top number of lines of the message can be read. This can safely be cast to a
* {@link java.io.BufferedReader BufferedReader} in order to use the {@link java.io.BufferedReader#readLine() BufferedReader#readLine()} method.
* Returns null if the retrieval attempt fails (e.g., if the specified message number does not exist).
* @throws IOException If a network I/O error occurs in the process of sending the top command.
*/
public Reader retrieveMessageTop(final int messageId, final int numLines) throws IOException {
if (numLines < 0 || getState() != TRANSACTION_STATE) {
return null;
}
if (sendCommand(POP3Command.TOP, Integer.toString(messageId) + " " + Integer.toString(numLines)) != POP3Reply.OK) {
return null;
}
return new DotTerminatedMessageReader(reader);
}
/**
* Get the mailbox status. A status attempt can only succeed if the client is in the {@link org.apache.commons.net.pop3.POP3#TRANSACTION_STATE
* TRANSACTION_STATE } . Returns a POP3MessageInfo instance containing the number of messages in the mailbox and the total size of the messages in bytes.
* Returns null if the status the attempt fails.
*
* @return A POP3MessageInfo instance containing the number of messages in the mailbox and the total size of the messages in bytes. Returns null if the
* status the attempt fails.
* @throws IOException If a network I/O error occurs in the process of sending the status command.
*/
public POP3MessageInfo status() throws IOException {
if (getState() != TRANSACTION_STATE) {
return null;
}
if (sendCommand(POP3Command.STAT) != POP3Reply.OK) {
return null;
}
return parseStatus(lastReplyLine.substring(3));
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/POP3Command.java 0000664 0000000 0000000 00000005342 14340477222 0031461 0 ustar 00root root 0000000 0000000 /*
* 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.pop3;
/**
* POP3Command stores POP3 command code constants.
*
*
*/
public final class POP3Command {
/** Send user name. */
public static final int USER = 0;
/** Send password. */
public static final int PASS = 1;
/** Quit session. */
public static final int QUIT = 2;
/** Get status. */
public static final int STAT = 3;
/** List message(s). */
public static final int LIST = 4;
/** Retrieve message(s). */
public static final int RETR = 5;
/** Delete message(s). */
public static final int DELE = 6;
/** No operation. Used as a session keepalive. */
public static final int NOOP = 7;
/** Reset session. */
public static final int RSET = 8;
/** Authorization. */
public static final int APOP = 9;
/** Retrieve top number lines from message. */
public static final int TOP = 10;
/** List unique message identifier(s). */
public static final int UIDL = 11;
/**
* The capabilities command.
*
* @since 3.0
*/
public static final int CAPA = 12;
/**
* Authentication
*
* @since 3.0
*/
public static final int AUTH = 13;
private static final int NEXT = AUTH + 1; // update as necessary when adding new entries
static final String[] commands = { "USER", "PASS", "QUIT", "STAT", "LIST", "RETR", "DELE", "NOOP", "RSET", "APOP", "TOP", "UIDL", "CAPA", "AUTH", };
static {
if (commands.length != NEXT) {
throw new RuntimeException("Error in array definition");
}
}
/**
* Get the POP3 protocol string command corresponding to a command code.
*
* @param command the command code
*
* @return The POP3 protocol string command corresponding to a command code.
*/
public static String getCommand(final int command) {
return commands[command];
}
// Cannot be instantiated.
private POP3Command() {
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/POP3MessageInfo.java 0000664 0000000 0000000 00000006022 14340477222 0032277 0 ustar 00root root 0000000 0000000 /*
* 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.pop3;
/**
* POP3MessageInfo is used to return information about messages stored on a POP3 server. Its fields are used to mean slightly different things depending on the
* information being returned.
*
* In response to a status command,
* In response to a message listings,
* In response to unique identifier listings,
*
* @param hostname The hostname of the sender.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 ehlo(final String hostname) throws IOException {
return sendCommand(SMTPCommand.EHLO, hostname);
}
/**
* Login to the ESMTP server by sending the EHLO command with the client hostname as an argument. Before performing any mail commands, you must first login.
*
*
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean elogin() throws IOException {
final String name;
final InetAddress host;
host = getLocalAddress();
name = host.getHostName();
if (name == null) {
return false;
}
return SMTPReply.isPositiveCompletion(ehlo(name));
}
/**
* Login to the ESMTP server by sending the EHLO command with the given hostname as an argument. Before performing any mail commands, you must first login.
*
*
* @param hostname The hostname with which to greet the SMTP server.
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean elogin(final String hostname) throws IOException {
return SMTPReply.isPositiveCompletion(ehlo(hostname));
}
/**
* Returns the integer values of the enhanced reply code of the last SMTP reply.
*
* @return The integer values of the enhanced reply code of the last SMTP reply. First digit is in the first array element.
*/
public int[] getEnhancedReplyCode() {
final String reply = getReplyString().substring(4);
final String[] parts = reply.substring(0, reply.indexOf(' ')).split("\\.");
final int[] res = new int[parts.length];
Arrays.setAll(res, i -> Integer.parseInt(parts[i]));
return res;
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/RelayPath.java 0000664 0000000 0000000 00000005627 14340477222 0031442 0 ustar 00root root 0000000 0000000 /*
* 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.smtp;
import java.util.Enumeration;
import java.util.Vector;
/**
* A class used to represent forward and reverse relay paths. The SMTP MAIL command requires a reverse relay path while the SMTP RCPT command requires a forward
* relay path. See RFC 821 for more details. In general, you will not have to deal with relay paths.
*
* @see SMTPClient
*/
public final class RelayPath {
private final Vector
*
* @param emailAddress The destination email address.
*/
public RelayPath(final String emailAddress) {
this.path = new Vector<>();
this.emailAddress = emailAddress;
}
/**
* Add a mail relay host to the relay path. Hosts are added left to right. For example, the following will create the path
*
*
* @param hostname The host to add to the relay path.
*/
public void addRelay(final String hostname) {
path.addElement(hostname);
}
/**
* Return the properly formatted string representation of the relay path.
*
*
* @return The properly formatted string representation of the relay path.
*/
@Override
public String toString() {
final StringBuilder buffer = new StringBuilder();
final Enumeration
* 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
* a command. When that occurs, the SMTP class method encountering that reply will throw an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} .
*
* 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 SMTPClient
* @see SMTPConnectionClosedException
* @see org.apache.commons.net.MalformedServerReplyException
*/
public class SMTP extends SocketClient {
/** The default SMTP port (25). */
public static final int DEFAULT_PORT = 25;
// 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 String DEFAULT_ENCODING = "ISO-8859-1";
/**
* The encoding to use (user-settable).
*
* @since 3.1 (changed from private to protected)
*/
protected final String encoding;
/**
* A ProtocolCommandSupport object used to manage the registering of ProtocolCommandListeners and te firing of ProtocolCommandEvents.
*/
protected ProtocolCommandSupport _commandSupport_;
BufferedReader reader;
BufferedWriter writer;
private int replyCode;
private final ArrayList
*
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 data() throws IOException {
return sendCommand(SMTPCommand.DATA);
}
/**
* Closes the connection to the SMTP 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.
*
*
* @throws IOException If an error occurs while disconnecting.
*/
@Override
public void disconnect() throws IOException {
super.disconnect();
reader = null;
writer = null;
replyString = null;
replyLines.clear();
newReplyString = false;
}
/**
* A convenience method to send the SMTP VRFY command to the server, receive the reply, and return the reply code.
*
*
* @param name The name to expand.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 expn(final String name) throws IOException {
return sendCommand(SMTPCommand.EXPN, name);
}
/**
* Provide command support to super-class
*/
@Override
protected ProtocolCommandSupport getCommandSupport() {
return _commandSupport_;
}
/**
* Fetches 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
* 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.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 {
final int length;
newReplyString = true;
replyLines.clear();
String line = reader.readLine();
if (line == null) {
throw new SMTPConnectionClosedException("Connection closed without indication.");
}
// In case we run into an anomaly we don't want fatal index exceptions
// to be thrown.
length = line.length();
if (length < 3) {
throw new MalformedServerReplyException("Truncated server reply: " + line);
}
try {
final String code = line.substring(0, 3);
replyCode = Integer.parseInt(code);
} catch (final NumberFormatException e) {
throw new MalformedServerReplyException("Could not parse response code.\nServer Reply: " + line);
}
replyLines.add(line);
// Get extra lines if message continues.
if (length > 3 && line.charAt(3) == '-') {
do {
line = reader.readLine();
if (line == null) {
throw new SMTPConnectionClosedException("Connection closed without indication.");
}
replyLines.add(line);
// The length() check handles problems that could arise from readLine()
// returning too soon after encountering a naked CR or some other
// anomaly.
} while (!(line.length() >= 4 && line.charAt(3) != '-' && Character.isDigit(line.charAt(0))));
// This is too strong a condition because a non-conforming server
// could screw things up like ftp.funet.fi does for FTP
// line.startsWith(code)));
}
fireReplyReceived(replyCode, getReplyString());
if (replyCode == SMTPReply.SERVICE_NOT_AVAILABLE) {
throw new SMTPConnectionClosedException("SMTP response 421 received. Server closed connection.");
}
return replyCode;
}
/**
* Returns the integer value of the reply code of the last SMTP reply. You will usually only use this method after you connect to the SMTP server to check
* that the connection was successful since
*
* @return The integer value of the reply code of the last SMTP reply.
*/
public int getReplyCode() {
return replyCode;
}
/**
* Returns the entire text of the last SMTP server response exactly as it was received, including all end of line markers in NETASCII format.
*
*
* @return The entire text from the last SMTP response as a String.
*/
public String getReplyString() {
final StringBuilder buffer;
if (!newReplyString) {
return replyString;
}
buffer = new StringBuilder();
for (final String line : replyLines) {
buffer.append(line);
buffer.append(SocketClient.NETASCII_EOL);
}
newReplyString = false;
replyString = buffer.toString();
return replyString;
}
/**
* Returns the lines of text from the last SMTP server response as an array of strings, one entry per line. The end of line markers of each are stripped
* from each line.
*
*
* @return The lines of text from the last SMTP response as an array.
*/
public String[] getReplyStrings() {
return replyLines.toArray(NetConstants.EMPTY_STRING_ARRAY);
}
/**
* A convenience method to send the SMTP HELO command to the server, receive the reply, and return the reply code.
*
*
* @param hostname The hostname of the sender.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 helo(final String hostname) throws IOException {
return sendCommand(SMTPCommand.HELO, hostname);
}
/**
* A convenience method to send the SMTP HELP command to the server, receive the reply, and return the reply code.
*
*
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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(SMTPCommand.HELP);
}
/**
* A convenience method to send the SMTP HELP command to the server, receive the reply, and return the reply code.
*
*
* @param command The command name on which to request help.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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(final String command) throws IOException {
return sendCommand(SMTPCommand.HELP, command);
}
/**
* A convenience method to send the SMTP MAIL command to the server, receive the reply, and return the reply code.
*
*
* @param reversePath The reverese path.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 mail(final String reversePath) throws IOException {
return sendCommand(SMTPCommand.MAIL, reversePath, false);
}
/**
* A convenience method to send the SMTP NOOP command to the server, receive the reply, and return the reply code.
*
*
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 noop() throws IOException {
return sendCommand(SMTPCommand.NOOP);
}
/**
* A convenience method to send the SMTP QUIT command to the server, receive the reply, and return the reply code.
*
*
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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(SMTPCommand.QUIT);
}
/**
* A convenience method to send the SMTP RCPT command to the server, receive the reply, and return the reply code.
*
*
* @param forwardPath The forward path.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 rcpt(final String forwardPath) throws IOException {
return sendCommand(SMTPCommand.RCPT, forwardPath, false);
}
/**
* Removes a ProtocolCommandListener.
*
* Delegates this incorrectly named method - removeProtocolCommandistener (note the missing "L")- to the correct method
* {@link SocketClient#removeProtocolCommandListener}
*
* @param listener The ProtocolCommandListener to remove
*/
public void removeProtocolCommandistener(final org.apache.commons.net.ProtocolCommandListener listener) {
removeProtocolCommandListener(listener);
}
/**
* A convenience method to send the SMTP RSET command to the server, receive the reply, and return the reply code.
*
*
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 rset() throws IOException {
return sendCommand(SMTPCommand.RSET);
}
/**
* A convenience method to send the SMTP SAML command to the server, receive the reply, and return the reply code.
*
*
* @param reversePath The reverese path.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 saml(final String reversePath) throws IOException {
return sendCommand(SMTPCommand.SAML, reversePath);
}
/**
* A convenience method to send the SMTP SEND command to the server, receive the reply, and return the reply code.
*
*
* @param reversePath The reverese path.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 send(final String reversePath) throws IOException {
return sendCommand(SMTPCommand.SEND, reversePath);
}
/**
* 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 }.
*
*
* @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.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 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 }.
*
*
* @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.
* @return The integer value of the SMTP reply code returned by the server in response to the command.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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(SMTPCommand.getCommand(command), args);
}
/**
*
* @param command the command to send (as an int defined in {@link SMPTCommand})
* @param args the command arguments, may be {@code null}
* @param includeSpace if {@code true}, add a space between the command and its arguments
* @return the reply code
* @throws IOException
*/
private int sendCommand(final int command, final String args, final boolean includeSpace) throws IOException {
return sendCommand(SMTPCommand.getCommand(command), args, includeSpace);
}
/**
* 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 }.
*
*
* @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.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 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 }.
*
*
* @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.
* @return The integer value of the SMTP reply code returned by the server in response to the command.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 {
return sendCommand(command, args, true);
}
/**
* Send a command to the server. May also be used to send text data.
*
* @param command the command to send (as a plain String)
* @param args the command arguments, may be {@code null}
* @param includeSpace if {@code true}, add a space between the command and its arguments
* @return the reply code
* @throws IOException
*/
private int sendCommand(final String command, final String args, final boolean includeSpace) throws IOException {
final StringBuilder __commandBuffer = new StringBuilder();
__commandBuffer.append(command);
if (args != null) {
if (includeSpace) {
__commandBuffer.append(' ');
}
__commandBuffer.append(args);
}
__commandBuffer.append(SocketClient.NETASCII_EOL);
final String message = __commandBuffer.toString();
writer.write(message);
writer.flush();
fireCommandSent(command, message);
return getReply();
}
/**
* A convenience method to send the SMTP SOML command to the server, receive the reply, and return the reply code.
*
*
* @param reversePath The reverese path.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 soml(final String reversePath) throws IOException {
return sendCommand(SMTPCommand.SOML, reversePath);
}
/**
* A convenience method to send the SMTP TURN command to the server, receive the reply, and return the reply code.
*
*
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 turn() throws IOException {
return sendCommand(SMTPCommand.TURN);
}
/**
* A convenience method to send the SMTP VRFY command to the server, receive the reply, and return the reply code.
*
*
* @param user The user address to verify.
* @return The reply code received from the server.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. 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 vrfy(final String user) throws IOException {
return sendCommand(SMTPCommand.VRFY, user);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/SMTPClient.java 0000664 0000000 0000000 00000063753 14340477222 0031477 0 ustar 00root root 0000000 0000000 /*
* 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.smtp;
import java.io.IOException;
import java.io.Writer;
import java.net.InetAddress;
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
* SMTP reply code to see if the connection was successful. For example:
*
*
* Immediately after connecting is the only real time you need to check the reply code (because connect is of type void). The convention for all the SMTP
* 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.
*
* 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 }
* response to a command. When that occurs, the method encountering that reply will throw an {@link org.apache.commons.net.smtp.SMTPConnectionClosedException} .
*
* 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 SMTP
* @see SimpleSMTPHeader
* @see RelayPath
* @see SMTPConnectionClosedException
* @see org.apache.commons.net.MalformedServerReplyException
*/
public class SMTPClient extends SMTP {
/**
* Default SMTPClient constructor. Creates a new SMTPClient instance.
*/
public SMTPClient() {
}
/**
* Overloaded constructor that takes an encoding specification
*
* @param encoding The encoding to use
* @since 2.0
*/
public SMTPClient(final String encoding) {
super(encoding);
}
/**
* Add a recipient for a message using the SMTP RCPT command, specifying a forward relay path. The sender must be set first before any recipients may be
* specified, otherwise the mail server will reject your commands.
*
*
* @param path The forward relay path pointing to the recipient.
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean addRecipient(final RelayPath path) throws IOException {
return SMTPReply.isPositiveCompletion(rcpt(path.toString()));
}
/**
* Add a recipient for a message using the SMTP RCPT command, the recipient's email address. The sender must be set first before any recipients may be
* specified, otherwise the mail server will reject your commands.
*
*
* @param address The recipient's email address.
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean addRecipient(final String address) throws IOException {
return SMTPReply.isPositiveCompletion(rcpt("<" + address + ">"));
}
/**
* 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.
*
* For example,
*
*
*
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean completePendingCommand() throws IOException {
return SMTPReply.isPositiveCompletion(getReply());
}
/**
* Fetches the system help information from the server and returns the full string.
*
*
* @return The system help string obtained from the server. null if the information could not be obtained.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String listHelp() throws IOException {
if (SMTPReply.isPositiveCompletion(help())) {
return getReplyString();
}
return null;
}
/**
* Fetches the help information for a given command from the server and returns the full string.
*
*
* @param command The command on which to ask for help.
* @return The command help string obtained from the server. null if the information could not be obtained.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String listHelp(final String command) throws IOException {
if (SMTPReply.isPositiveCompletion(help(command))) {
return getReplyString();
}
return null;
}
/**
* Login to the SMTP server by sending the HELO command with the client hostname as an argument. Before performing any mail commands, you must first login.
*
*
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean login() throws IOException {
final String name;
final InetAddress host;
host = getLocalAddress();
name = host.getHostName();
if (name == null) {
return false;
}
return SMTPReply.isPositiveCompletion(helo(name));
}
/**
* Login to the SMTP server by sending the HELO command with the given hostname as an argument. Before performing any mail commands, you must first login.
*
*
* @param hostname The hostname with which to greet the SMTP server.
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean login(final String hostname) throws IOException {
return SMTPReply.isPositiveCompletion(helo(hostname));
}
/**
* Logout of the SMTP server by sending the QUIT command.
*
*
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean logout() throws IOException {
return SMTPReply.isPositiveCompletion(quit());
}
/**
* Aborts the current mail transaction, resetting all server stored sender, recipient, and mail data, cleaing all buffers and tables.
*
*
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean reset() throws IOException {
return SMTPReply.isPositiveCompletion(rset());
}
/**
* Send the SMTP DATA command in preparation to send an email message. This method returns a DotTerminatedMessageWriter instance to which the message can be
* written. Null is returned if the DATA command fails.
*
* You must not issue any commands to the SMTP server (i.e., call any (other methods) until you finish writing to the returned Writer instance and close it.
* The SMTP protocol uses the same stream for issuing commands as it does for returning results. Therefore the returned Writer actually writes directly to
* the SMTP connection. After you close the writer, you can execute new commands. If you do not follow these requirements your program will not work
* properly.
*
* You can use the provided {@link org.apache.commons.net.smtp.SimpleSMTPHeader} class to construct a bare minimum header. To construct more complicated
* headers you should refer to RFC 5322. When the Java Mail API is finalized, you will be able to use it to compose fully compliant Internet text messages.
* The DotTerminatedMessageWriter takes care of doubling line-leading dots and ending the message with a single dot upon closing, so all you have to worry
* about is writing the header and the message.
*
* Upon closing the returned Writer, you need to call {@link #completePendingCommand completePendingCommand() } to finalize the transaction and verify its
* success or failure from the server reply.
*
*
* @return A DotTerminatedMessageWriter to which the message (including header) can be written. Returns null if the command fails.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @see #sendShortMessageData(String)
*/
public Writer sendMessageData() throws IOException {
if (!SMTPReply.isPositiveIntermediate(data())) {
return null;
}
return new DotTerminatedMessageWriter(writer);
}
/**
* Sends a NOOP command to the SMTP server. This is useful for preventing server timeouts.
*
*
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean sendNoOp() throws IOException {
return SMTPReply.isPositiveCompletion(noop());
}
/**
* A convenience method for sending short messages. This method fetches the Writer returned by {@link #sendMessageData sendMessageData() } and writes the
* specified String to it. After writing the message, this method calls {@link #completePendingCommand completePendingCommand() } to finalize the
* transaction and returns its success or failure.
*
*
* @param message The short email message to send. This must include the headers and the body, but not the trailing "."
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean sendShortMessageData(final String message) throws IOException {
try (final Writer writer = sendMessageData()) {
if (writer == null) {
return false;
}
writer.write(message);
}
return completePendingCommand();
}
/**
* A convenience method for a sending 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
* sendShortMessageData }.
*
*
* @param sender The email address of the sender.
* @param recipient The email address of the recipient.
* @param message The short email message to send. This must include the headers and the body, but not the trailing "."
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean sendSimpleMessage(final String sender, final String recipient, final String message) throws IOException {
if (!setSender(sender)) {
return false;
}
if (!addRecipient(recipient)) {
return false;
}
return sendShortMessageData(message);
}
/**
* A convenience method for a sending short email without having to explicitly set the sender and recipient(s). This method sets the sender and recipients
* using {@link #setSender(String) setSender} and {@link #addRecipient(String) addRecipient}, and then sends the message using
* {@link #sendShortMessageData(String) sendShortMessageData}.
*
* Note that the method ignores failures when calling {@link #addRecipient(String) addRecipient} so long as at least one call succeeds. If no recipients can
* be successfully added then the method will fail (and does not attempt to send the message)
*
*
* @param sender The email address of the sender.
* @param recipients An array of recipient email addresses.
* @param message The short email message to send. This must include the headers and the body, but not the trailing "."
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean sendSimpleMessage(final String sender, final String[] recipients, final String message) throws IOException {
boolean oneSuccess = false;
int count;
if (!setSender(sender)) {
return false;
}
for (count = 0; count < recipients.length; count++) {
if (addRecipient(recipients[count])) {
oneSuccess = true;
}
}
if (!oneSuccess) {
return false;
}
return sendShortMessageData(message);
}
/**
* Set the sender of a message using the SMTP MAIL command, specifying a reverse relay path. The sender must be set first before any recipients may be
* specified, otherwise the mail server will reject your commands.
*
*
* @param path The reverse relay path pointing back to the sender.
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean setSender(final RelayPath path) throws IOException {
return SMTPReply.isPositiveCompletion(mail(path.toString()));
}
/**
* Set the sender of a message using the SMTP MAIL command, specifying the sender's email address. The sender must be set first before any recipients may be
* specified, otherwise the mail server will reject your commands.
*
*
* @param address The sender's email address.
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean setSender(final String address) throws IOException {
return SMTPReply.isPositiveCompletion(mail("<" + address + ">"));
}
/**
* Verify that a username or email address is valid, i.e., that mail can be delivered to that mailbox on the server.
*
*
* @param username The username or email address to validate.
* @return True if the username is valid, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean verify(final String username) throws IOException {
final int result;
result = vrfy(username);
return result == SMTPReply.ACTION_OK || result == SMTPReply.USER_NOT_LOCAL_WILL_FORWARD;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/SMTPCommand.java 0000664 0000000 0000000 00000007117 14340477222 0031627 0 ustar 00root root 0000000 0000000 /*
* 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.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.
*/
public final class SMTPCommand {
public static final int HELO = 0;
public static final int MAIL = 1;
public static final int RCPT = 2;
public static final int DATA = 3;
public static final int SEND = 4;
public static final int SOML = 5;
public static final int SAML = 6;
public static final int RSET = 7;
public static final int VRFY = 8;
public static final int EXPN = 9;
public static final int HELP = 10;
public static final int NOOP = 11;
public static final int TURN = 12;
public static final int QUIT = 13;
/**
* The authorization command
*
* @since 3.0
*/
public static final int AUTH = 14;
/**
* The extended hello command
*
* @since 3.0
*/
public static final int EHLO = 15;
private static final int NEXT = EHLO + 1; // update as necessary when adding new entries
public static final int HELLO = HELO;
public static final int LOGIN = HELO;
public static final int MAIL_FROM = MAIL;
public static final int RECIPIENT = RCPT;
public static final int SEND_MESSAGE_DATA = DATA;
public static final int SEND_FROM = SEND;
public static final int SEND_OR_MAIL_FROM = SOML;
public static final int SEND_AND_MAIL_FROM = SAML;
public static final int RESET = RSET;
public static final int VERIFY = VRFY;
public static final int EXPAND = EXPN;
// public static final int HELP = HELP;
// public static final int NOOP = NOOP;
// public static final int TURN = TURN;
// public static final int QUIT = QUIT;
public static final int LOGOUT = QUIT;
private static final String[] commands = { "HELO", "MAIL FROM:", "RCPT TO:", "DATA", "SEND FROM:", "SOML FROM:", "SAML FROM:", "RSET", "VRFY", "EXPN",
"HELP", "NOOP", "TURN", "QUIT", "AUTH", "EHLO" };
static {
if (commands.length != NEXT) {
throw new RuntimeException("Error in array definition");
}
}
/**
* Retrieve the SMTP protocol command string corresponding to a specified command code.
*
*
* @param command The command code.
* @return The SMTP protcol command string corresponding to a specified command code.
*/
public static String getCommand(final int command) {
return commands[command];
}
// Cannot be instantiated
private SMTPCommand() {
}
}
SMTPConnectionClosedException.java 0000664 0000000 0000000 00000003550 14340477222 0035277 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp /*
* 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.smtp;
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.
* This exception is derived from IOException and therefore may be caught either as an IOException or specifically as an SMTPConnectionClosedException.
*
*
* @see SMTP
* @see SMTPClient
*/
public final class SMTPConnectionClosedException extends IOException {
private static final long serialVersionUID = 626520434326660627L;
/** Constructs a SMTPConnectionClosedException with no message */
public SMTPConnectionClosedException() {
}
/**
* Constructs a SMTPConnectionClosedException with a specified message.
*
* @param message The message explaining the reason for the exception.
*/
public SMTPConnectionClosedException(final String message) {
super(message);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/SMTPReply.java 0000664 0000000 0000000 00000012504 14340477222 0031340 0 ustar 00root root 0000000 0000000 /*
* 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.smtp;
/**
* SMTPReply stores a set of constants for SMTP reply 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.
*/
public final class SMTPReply {
public static final int SYSTEM_STATUS = 211;
public static final int HELP_MESSAGE = 214;
public static final int SERVICE_READY = 220;
public static final int SERVICE_CLOSING_TRANSMISSION_CHANNEL = 221;
public static final int ACTION_OK = 250;
public static final int USER_NOT_LOCAL_WILL_FORWARD = 251;
public static final int START_MAIL_INPUT = 354;
public static final int SERVICE_NOT_AVAILABLE = 421;
public static final int ACTION_NOT_TAKEN = 450;
public static final int ACTION_ABORTED = 451;
public static final int INSUFFICIENT_STORAGE = 452;
public static final int UNRECOGNIZED_COMMAND = 500;
public static final int SYNTAX_ERROR_IN_ARGUMENTS = 501;
public static final int COMMAND_NOT_IMPLEMENTED = 502;
public static final int BAD_COMMAND_SEQUENCE = 503;
public static final int COMMAND_NOT_IMPLEMENTED_FOR_PARAMETER = 504;
public static final int MAILBOX_UNAVAILABLE = 550;
public static final int USER_NOT_LOCAL = 551;
public static final int STORAGE_ALLOCATION_EXCEEDED = 552;
public static final int MAILBOX_NAME_NOT_ALLOWED = 553;
public static final int TRANSACTION_FAILED = 554;
/**
* Determine if a reply code is a negative permanent response. All codes beginning with a 5 are negative permanent responses. The SMTP server will send a
* negative permanent response on the failure of a command that cannot be reattempted with success.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a negative permanent response, false if not.
*/
public static boolean isNegativePermanent(final int reply) {
return reply >= 500 && reply < 600;
}
/**
* Determine if a reply code is a negative transient response. All codes beginning with a 4 are negative transient responses. The SMTP server will send a
* negative transient response on the failure of a command that can be reattempted with success.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a negative transient response, false if not.
*/
public static boolean isNegativeTransient(final int reply) {
return reply >= 400 && reply < 500;
}
/**
* Determine if a reply code is a positive completion response. All codes beginning with a 2 are positive completion responses. The SMTP server will send a
* positive completion response on the final successful completion of a command.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a positive completion response, false if not.
*/
public static boolean isPositiveCompletion(final int reply) {
return reply >= 200 && reply < 300;
}
/**
* Determine if a reply code is a positive intermediate response. All codes beginning with a 3 are positive intermediate responses. The SMTP server will
* send a positive intermediate response on the successful completion of one part of a multi-part sequence of commands. For example, after a successful DATA
* command, a positive intermediate response will be sent to indicate that the server is ready to receive the message data.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a positive intermediate response, false if not.
*/
public static boolean isPositiveIntermediate(final int reply) {
return reply >= 300 && reply < 400;
}
/**
* Determine if a reply code is a positive preliminary response. All codes beginning with a 1 are positive preliminary responses. Postitive preliminary
* responses are used to indicate tentative success. No further commands can be issued to the SMTP server after a positive preliminary response until a
* follow up response is received from the server.
*
* Note: No SMTP commands defined in RFC 822 provide this type of reply.
*
*
* @param reply The reply code to test.
* @return True if a reply code is a positive preliminary response, false if not.
*/
public static boolean isPositivePreliminary(final int reply) {
return reply >= 100 && reply < 200;
}
// Cannot be instantiated
private SMTPReply() {
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/SMTPSClient.java 0000664 0000000 0000000 00000030653 14340477222 0031613 0 ustar 00root root 0000000 0000000 /*
* 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.smtp;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import org.apache.commons.net.io.CRLFLineReader;
import org.apache.commons.net.util.SSLContextUtils;
import org.apache.commons.net.util.SSLSocketUtils;
/**
* SMTP over SSL processing. Copied from FTPSClient.java and modified to suit SMTP. If implicit mode is selected (NOT the default), SSL/TLS negotiation starts
* right after the connection has been established. In explicit mode (the default), SSL/TLS negotiation starts when the user calls execTLS() and the server
* accepts the command. Implicit usage:
*
*
* The main purpose of the class is to faciliatate the mail sending process, by relieving the programmer from having to explicitly format a simple message
* header. For example:
*
*
*
* @param from The value of the
*
* @param address The email address to add to the CC list.
*/
public void addCC(final String address) {
if (cc == null) {
cc = new StringBuffer();
} else {
cc.append(", ");
}
cc.append(address);
}
/**
* Adds an arbitrary header field with the given value to the article header. These headers will be written before the From, To, Subject, and Cc fields when
* the SimpleSMTPHeader is convertered to a string. An example use would be:
*
*
*
* @param headerField The header field to add, not including the colon.
* @param value The value of the added header field.
*/
public void addHeaderField(final String headerField, final String value) {
if (!hasHeaderDate && "Date".equals(headerField)) {
hasHeaderDate = true;
}
headerFields.append(headerField);
headerFields.append(": ");
headerFields.append(value);
headerFields.append('\n');
}
/**
* Converts the SimpleSMTPHeader to a properly formatted header in the form of a String, including the blank line used to separate the header from the
* article body. The header fields CC and Subject are only included when they are non-null.
*
*
* @return The message header in the form of a String.
*/
@Override
public String toString() {
final StringBuilder header = new StringBuilder();
final String pattern = "EEE, dd MMM yyyy HH:mm:ss Z"; // Fri, 21 Nov 1997 09:55:06 -0600
final SimpleDateFormat format = new SimpleDateFormat(pattern, Locale.ENGLISH);
if (!hasHeaderDate) {
addHeaderField("Date", format.format(new Date()));
}
if (headerFields.length() > 0) {
header.append(headerFields.toString());
}
header.append("From: ").append(from).append("\n");
if (to != null) {
header.append("To: ").append(to).append("\n");
}
if (cc != null) {
header.append("Cc: ").append(cc.toString()).append("\n");
}
if (subject != null) {
header.append("Subject: ").append(subject).append("\n");
}
header.append('\n'); // end of headers; body follows
return header.toString();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/package-info.java 0000664 0000000 0000000 00000001547 14340477222 0032072 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* SMTP and SMTPS mail
*/
package org.apache.commons.net.smtp; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet/ 0000775 0000000 0000000 00000000000 14340477222 0027204 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet/EchoOptionHandler.java0000664 0000000 0000000 00000003646 14340477222 0033425 0 ustar 00root root 0000000 0000000 /*
* 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.telnet;
/**
* Implements the telnet echo option RFC 857.
*/
public class EchoOptionHandler extends TelnetOptionHandler {
/**
* Constructor for the EchoOptionHandler. Initial and accept behavior flags are set to false
*/
public EchoOptionHandler() {
super(TelnetOption.ECHO, false, false, false, false);
}
/**
* Constructor for the EchoOptionHandler. Allows defining desired initial setting for local/remote activation of this option and behavior in case a
* local/remote activation request for this option is received.
*
*
* @param initlocal - if set to true, a WILL is sent upon connection.
* @param initremote - if set to true, a DO is sent upon connection.
* @param acceptlocal - if set to true, any DO request is accepted.
* @param acceptremote - if set to true, any WILL request is accepted.
*/
public EchoOptionHandler(final boolean initlocal, final boolean initremote, final boolean acceptlocal, final boolean acceptremote) {
super(TelnetOption.ECHO, initlocal, initremote, acceptlocal, acceptremote);
}
}
InvalidTelnetOptionException.java 0000664 0000000 0000000 00000003423 14340477222 0035604 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* The InvalidTelnetOptionException is the exception that is thrown whenever a TelnetOptionHandler with an invlaid option code is registered in TelnetClient
* with addOptionHandler.
*/
public class InvalidTelnetOptionException extends Exception {
private static final long serialVersionUID = -2516777155928793597L;
/**
* Option code
*/
private final int optionCode;
/**
* Error message
*/
private final String msg;
/**
* Constructor for the exception.
*
*
* @param message - Error message.
* @param optcode - Option code.
*/
public InvalidTelnetOptionException(final String message, final int optcode) {
optionCode = optcode;
msg = message;
}
/**
* Gets the error message of ths exception.
*
*
* @return the error message.
*/
@Override
public String getMessage() {
return msg + ": " + optionCode;
}
}
SimpleOptionHandler.java 0000664 0000000 0000000 00000004114 14340477222 0033710 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* Simple option handler that can be used for options that don't require subnegotiation.
*/
public class SimpleOptionHandler extends TelnetOptionHandler {
/**
* Constructor for the SimpleOptionHandler. Initial and accept behavior flags are set to false
*
*
* @param optcode - option code.
*/
public SimpleOptionHandler(final int optcode) {
super(optcode, false, false, false, false);
}
/**
* Constructor for the SimpleOptionHandler. Allows defining desired initial setting for local/remote activation of this option and behavior in case a
* local/remote activation request for this option is received.
*
*
* @param optcode - option code.
* @param initlocal - if set to true, a WILL is sent upon connection.
* @param initremote - if set to true, a DO is sent upon connection.
* @param acceptlocal - if set to true, any DO request is accepted.
* @param acceptremote - if set to true, any WILL request is accepted.
*/
public SimpleOptionHandler(final int optcode, final boolean initlocal, final boolean initremote, final boolean acceptlocal, final boolean acceptremote) {
super(optcode, initlocal, initremote, acceptlocal, acceptremote);
}
}
SuppressGAOptionHandler.java 0000664 0000000 0000000 00000003753 14340477222 0034523 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* Implements the telnet suppress go ahead option RFC 858.
*/
public class SuppressGAOptionHandler extends TelnetOptionHandler {
/**
* Constructor for the SuppressGAOptionHandler. Initial and accept behavior flags are set to false
*/
public SuppressGAOptionHandler() {
super(TelnetOption.SUPPRESS_GO_AHEAD, false, false, false, false);
}
/**
* Constructor for the SuppressGAOptionHandler. Allows defining desired initial setting for local/remote activation of this option and behavior in case a
* local/remote activation request for this option is received.
*
*
* @param initlocal - if set to true, a WILL is sent upon connection.
* @param initremote - if set to true, a DO is sent upon connection.
* @param acceptlocal - if set to true, any DO request is accepted.
* @param acceptremote - if set to true, any WILL request is accepted.
*/
public SuppressGAOptionHandler(final boolean initlocal, final boolean initremote, final boolean acceptlocal, final boolean acceptremote) {
super(TelnetOption.SUPPRESS_GO_AHEAD, initlocal, initremote, acceptlocal, acceptremote);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet/Telnet.java 0000664 0000000 0000000 00000073522 14340477222 0031313 0 ustar 00root root 0000000 0000000 /*
* 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.telnet;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import org.apache.commons.net.SocketClient;
class Telnet extends SocketClient {
static final boolean debug = /* true; */ false;
static final boolean debugoptions = /* true; */ false;
static final byte[] COMMAND_DO = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO };
static final byte[] COMMAND_DONT = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT };
static final byte[] COMMAND_WILL = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL };
static final byte[] COMMAND_WONT = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT };
static final byte[] COMMAND_SB = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB };
static final byte[] COMMAND_SE = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE };
static final int WILL_MASK = 0x01;
static final int DO_MASK = 0x02;
static final int REQUESTED_WILL_MASK = 0x04;
static final int REQUESTED_DO_MASK = 0x08;
/* public */
static final int DEFAULT_PORT = 23;
/* TERMINAL-TYPE option (start) */
/**
* Terminal type option
*/
protected static final int TERMINAL_TYPE = 24;
/**
* Send (for subnegotiation)
*/
protected static final int TERMINAL_TYPE_SEND = 1;
/**
* Is (for subnegotiation)
*/
protected static final int TERMINAL_TYPE_IS = 0;
/**
* Is sequence (for subnegotiation)
*/
static final byte[] COMMAND_IS = { (byte) TERMINAL_TYPE, (byte) TERMINAL_TYPE_IS };
/* Code Section added for supporting AYT (start) */
/**
* AYT sequence
*/
static final byte[] COMMAND_AYT = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.AYT };
private final int[] doResponse;
private final int[] willResponse;
private final int[] options;
/**
* Terminal type
*/
private String terminalType;
/* TERMINAL-TYPE option (end) */
/* open TelnetOptionHandler functionality (end) */
/* open TelnetOptionHandler functionality (start) */
/**
* Array of option handlers
*/
private final TelnetOptionHandler[] optionHandlers;
/**
* monitor to wait for AYT
*/
private final Object aytMonitor = new Object();
/**
* flag for AYT
*/
private volatile boolean aytFlag = true;
/* Code Section added for supporting AYT (end) */
/**
* The stream on which to spy
*/
private volatile OutputStream spyStream;
/**
* The notification handler
*/
private TelnetNotificationHandler notifhand;
/**
* Empty Constructor
*/
Telnet() {
setDefaultPort(DEFAULT_PORT);
doResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
willResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
options = new int[TelnetOption.MAX_OPTION_VALUE + 1];
optionHandlers = new TelnetOptionHandler[TelnetOption.MAX_OPTION_VALUE + 1];
}
/* TERMINAL-TYPE option (start) */
/**
* This constructor lets you specify the terminal type.
*
* @param termtype - terminal type to be negotiated (ej. VT100)
*/
Telnet(final String termtype) {
setDefaultPort(DEFAULT_PORT);
doResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
willResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
options = new int[TelnetOption.MAX_OPTION_VALUE + 1];
terminalType = termtype;
optionHandlers = new TelnetOptionHandler[TelnetOption.MAX_OPTION_VALUE + 1];
}
/* TERMINAL-TYPE option (end) */
/**
* Called upon connection.
*
* @throws IOException - Exception in I/O.
*/
@Override
protected void _connectAction_() throws IOException {
/* (start). BUGFIX: clean the option info for each connection */
for (int ii = 0; ii < TelnetOption.MAX_OPTION_VALUE + 1; ii++) {
doResponse[ii] = 0;
willResponse[ii] = 0;
options[ii] = 0;
if (optionHandlers[ii] != null) {
optionHandlers[ii].setDo(false);
optionHandlers[ii].setWill(false);
}
}
/* (end). BUGFIX: clean the option info for each connection */
super._connectAction_();
_input_ = new BufferedInputStream(_input_);
_output_ = new BufferedOutputStream(_output_);
/* open TelnetOptionHandler functionality (start) */
for (int ii = 0; ii < TelnetOption.MAX_OPTION_VALUE + 1; ii++) {
if (optionHandlers[ii] != null) {
if (optionHandlers[ii].getInitLocal()) {
requestWill(optionHandlers[ii].getOptionCode());
}
if (optionHandlers[ii].getInitRemote()) {
requestDo(optionHandlers[ii].getOptionCode());
}
}
}
/* open TelnetOptionHandler functionality (end) */
}
/* Code Section added for supporting spystreams (start) */
/**
* Registers an OutputStream for spying what's going on in the Telnet session.
*
* @param spystream - OutputStream on which session activity will be echoed.
*/
void _registerSpyStream(final OutputStream spystream) {
spyStream = spystream;
}
/* Code Section added for supporting AYT (start) */
/**
* Sends an Are You There sequence and waits for the result.
*
* @param timeout - Time to wait for a response (millis.)
* @throws IOException - Exception in I/O.
* @throws IllegalArgumentException - Illegal argument
* @throws InterruptedException - Interrupted during wait.
* @return true if AYT received a response, false otherwise
**/
final boolean _sendAYT(final long timeout) throws IOException, IllegalArgumentException, InterruptedException {
boolean retValue = false;
synchronized (aytMonitor) {
synchronized (this) {
aytFlag = false;
_output_.write(COMMAND_AYT);
_output_.flush();
}
aytMonitor.wait(timeout);
if (!aytFlag) {
aytFlag = true;
} else {
retValue = true;
}
}
return retValue;
}
/* Code Section added for supporting AYT (end) */
/**
* Sends a command, automatically adds IAC prefix and flushes the output.
*
* @param cmd - command data to be sent
* @throws IOException - Exception in I/O.
* @since 3.0
*/
final synchronized void _sendCommand(final byte cmd) throws IOException {
_output_.write(TelnetCommand.IAC);
_output_.write(cmd);
_output_.flush();
}
/* open TelnetOptionHandler functionality (start) */
/**
* Manages subnegotiation for Terminal Type.
*
* @param subn - subnegotiation data to be sent
* @throws IOException - Exception in I/O.
**/
final synchronized void _sendSubnegotiation(final int[] subn) throws IOException {
if (debug) {
System.err.println("SEND SUBNEGOTIATION: ");
if (subn != null) {
System.err.println(Arrays.toString(subn));
}
}
if (subn != null) {
_output_.write(COMMAND_SB);
// Note _output_ is buffered, so might as well simplify by writing single bytes
for (final int element : subn) {
final byte b = (byte) element;
if (b == (byte) TelnetCommand.IAC) { // cast is necessary because IAC is outside the signed byte range
_output_.write(b); // double any IAC bytes
}
_output_.write(b);
}
_output_.write(COMMAND_SE);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
}
/* open TelnetOptionHandler functionality (end) */
/**
* Stops spying this Telnet.
*
*/
void _stopSpyStream() {
spyStream = null;
}
/**
* Registers a new TelnetOptionHandler for this telnet to use.
*
* @param opthand - option handler to be registered.
* @throws InvalidTelnetOptionException - The option code is invalid.
* @throws IOException on error
**/
void addOptionHandler(final TelnetOptionHandler opthand) throws InvalidTelnetOptionException, IOException {
final int optcode = opthand.getOptionCode();
if (!TelnetOption.isValidOption(optcode)) {
throw new InvalidTelnetOptionException("Invalid Option Code", optcode);
}
if (optionHandlers[optcode] != null) {
throw new InvalidTelnetOptionException("Already registered option", optcode);
}
optionHandlers[optcode] = opthand;
if (isConnected()) {
if (opthand.getInitLocal()) {
requestWill(optcode);
}
if (opthand.getInitRemote()) {
requestDo(optcode);
}
}
}
/**
* Unregisters a TelnetOptionHandler.
*
* @param optcode - Code of the option to be unregistered.
* @throws InvalidTelnetOptionException - The option code is invalid.
* @throws IOException on error
**/
void deleteOptionHandler(final int optcode) throws InvalidTelnetOptionException, IOException {
if (!TelnetOption.isValidOption(optcode)) {
throw new InvalidTelnetOptionException("Invalid Option Code", optcode);
}
if (optionHandlers[optcode] == null) {
throw new InvalidTelnetOptionException("Unregistered option", optcode);
}
final TelnetOptionHandler opthand = optionHandlers[optcode];
optionHandlers[optcode] = null;
if (opthand.getWill()) {
requestWont(optcode);
}
if (opthand.getDo()) {
requestDont(optcode);
}
}
/* open TelnetOptionHandler functionality (end) */
/* Code Section added for supporting AYT (start) */
/**
* Processes the response of an AYT
*/
final synchronized void processAYTResponse() {
if (!aytFlag) {
synchronized (aytMonitor) {
aytFlag = true;
aytMonitor.notifyAll();
}
}
}
/* Code Section added for supporting AYT (end) */
/**
* Processes a COMMAND.
*
* @param command - option code to be set.
**/
void processCommand(final int command) {
if (debugoptions) {
System.err.println("RECEIVED COMMAND: " + command);
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_COMMAND, command);
}
}
/**
* Processes a DO request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processDo(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED DO: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_DO, option);
}
boolean acceptNewState = false;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
acceptNewState = optionHandlers[option].getAcceptLocal();
} else if (option == TERMINAL_TYPE && terminalType != null && !terminalType.isEmpty()) {
acceptNewState = true;
}
/* TERMINAL-TYPE option (end) */
/* open TelnetOptionHandler functionality (start) */
if (willResponse[option] > 0) {
--willResponse[option];
if (willResponse[option] > 0 && stateIsWill(option)) {
--willResponse[option];
}
}
if (willResponse[option] == 0) {
if (requestedWont(option)) {
switch (option) {
default:
break;
}
if (acceptNewState) {
setWantWill(option);
sendWill(option);
} else {
++willResponse[option];
sendWont(option);
}
} else {
// Other end has acknowledged option.
switch (option) {
default:
break;
}
}
}
setWill(option);
}
/**
* Processes a DONT request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processDont(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED DONT: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_DONT, option);
}
if (willResponse[option] > 0) {
--willResponse[option];
if (willResponse[option] > 0 && stateIsWont(option)) {
--willResponse[option];
}
}
if (willResponse[option] == 0 && requestedWill(option)) {
switch (option) {
default:
break;
}
/* FIX for a BUG in the negotiation (start) */
if (stateIsWill(option) || requestedWill(option)) {
sendWont(option);
}
setWantWont(option);
/* FIX for a BUG in the negotiation (end) */
}
setWont(option);
}
/* TERMINAL-TYPE option (start) */
/**
* Processes a suboption negotiation.
*
* @param suboption - subnegotiation data received
* @param suboptionLength - length of data received
* @throws IOException - Exception in I/O.
**/
void processSuboption(final int[] suboption, final int suboptionLength) throws IOException {
if (debug) {
System.err.println("PROCESS SUBOPTION.");
}
/* open TelnetOptionHandler functionality (start) */
if (suboptionLength > 0) {
if (optionHandlers[suboption[0]] != null) {
final int[] responseSuboption = optionHandlers[suboption[0]].answerSubnegotiation(suboption, suboptionLength);
_sendSubnegotiation(responseSuboption);
} else if (suboptionLength > 1) {
if (debug) {
for (int ii = 0; ii < suboptionLength; ii++) {
System.err.println("SUB[" + ii + "]: " + suboption[ii]);
}
}
if (suboption[0] == TERMINAL_TYPE && suboption[1] == TERMINAL_TYPE_SEND) {
sendTerminalType();
}
}
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Processes a WILL request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processWill(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED WILL: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_WILL, option);
}
boolean acceptNewState = false;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
acceptNewState = optionHandlers[option].getAcceptRemote();
}
/* open TelnetOptionHandler functionality (end) */
if (doResponse[option] > 0) {
--doResponse[option];
if (doResponse[option] > 0 && stateIsDo(option)) {
--doResponse[option];
}
}
if (doResponse[option] == 0 && requestedDont(option)) {
switch (option) {
default:
break;
}
if (acceptNewState) {
setWantDo(option);
sendDo(option);
} else {
++doResponse[option];
sendDont(option);
}
}
setDo(option);
}
/**
* Processes a WONT request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processWont(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED WONT: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_WONT, option);
}
if (doResponse[option] > 0) {
--doResponse[option];
if (doResponse[option] > 0 && stateIsDont(option)) {
--doResponse[option];
}
}
if (doResponse[option] == 0 && requestedDo(option)) {
switch (option) {
default:
break;
}
/* FIX for a BUG in the negotiation (start) */
if (stateIsDo(option) || requestedDo(option)) {
sendDont(option);
}
setWantDont(option);
/* FIX for a BUG in the negotiation (end) */
}
setDont(option);
}
/**
* Registers a notification handler to which will be sent notifications of received telnet option negotiation commands.
*
* @param notifhand - TelnetNotificationHandler to be registered
*/
public void registerNotifHandler(final TelnetNotificationHandler notifhand) {
this.notifhand = notifhand;
}
/**
* Requests a DO.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestDo(final int option) throws IOException {
if (doResponse[option] == 0 && stateIsDo(option) || requestedDo(option)) {
return;
}
setWantDo(option);
++doResponse[option];
sendDo(option);
}
/**
* Requests a DONT.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestDont(final int option) throws IOException {
if (doResponse[option] == 0 && stateIsDont(option) || requestedDont(option)) {
return;
}
setWantDont(option);
++doResponse[option];
sendDont(option);
}
/**
* Looks for the state of the option.
*
* @return returns true if a do has been reuqested
*
* @param option - option code to be looked up.
*/
boolean requestedDo(final int option) {
return (options[option] & REQUESTED_DO_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a dont has been reuqested
*
* @param option - option code to be looked up.
*/
boolean requestedDont(final int option) {
return !requestedDo(option);
}
/**
* Looks for the state of the option.
*
* @return returns true if a will has been reuqested
*
* @param option - option code to be looked up.
*/
boolean requestedWill(final int option) {
return (options[option] & REQUESTED_WILL_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a wont has been reuqested
*
* @param option - option code to be looked up.
*/
boolean requestedWont(final int option) {
return !requestedWill(option);
}
/**
* Requests a WILL.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestWill(final int option) throws IOException {
if (willResponse[option] == 0 && stateIsWill(option) || requestedWill(option)) {
return;
}
setWantWill(option);
++doResponse[option];
sendWill(option);
}
/* TERMINAL-TYPE option (end) */
/**
* Requests a WONT.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestWont(final int option) throws IOException {
if (willResponse[option] == 0 && stateIsWont(option) || requestedWont(option)) {
return;
}
setWantWont(option);
++doResponse[option];
sendWont(option);
}
/**
* Sends a byte.
*
* @param b - byte to send
* @throws IOException - Exception in I/O.
**/
final synchronized void sendByte(final int b) throws IOException {
_output_.write(b);
/* Code Section added for supporting spystreams (start) */
spyWrite(b);
/* Code Section added for supporting spystreams (end) */
}
/**
* Sends a DO.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendDo(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("DO: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_DO);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sends a DONT.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendDont(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("DONT: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_DONT);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sends terminal type information.
*
* @throws IOException - Exception in I/O.
*/
final synchronized void sendTerminalType() throws IOException {
if (debug) {
System.err.println("SEND TERMINAL-TYPE: " + terminalType);
}
if (terminalType != null) {
_output_.write(COMMAND_SB);
_output_.write(COMMAND_IS);
_output_.write(terminalType.getBytes(getCharset()));
_output_.write(COMMAND_SE);
_output_.flush();
}
}
/**
* Sends a WILL.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendWill(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("WILL: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_WILL);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sends a WONT.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendWont(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("WONT: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_WONT);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
* @throws IOException
*/
void setDo(final int option) throws IOException {
options[option] |= DO_MASK;
/* open TelnetOptionHandler functionality (start) */
if (requestedDo(option) && (optionHandlers[option] != null)) {
optionHandlers[option].setDo(true);
final int[] subneg = optionHandlers[option].startSubnegotiationRemote();
if (subneg != null) {
_sendSubnegotiation(subneg);
}
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setDont(final int option) {
options[option] &= ~DO_MASK;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
optionHandlers[option].setDo(false);
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantDo(final int option) {
options[option] |= REQUESTED_DO_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantDont(final int option) {
options[option] &= ~REQUESTED_DO_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantWill(final int option) {
options[option] |= REQUESTED_WILL_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantWont(final int option) {
options[option] &= ~REQUESTED_WILL_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
* @throws IOException
*/
void setWill(final int option) throws IOException {
options[option] |= WILL_MASK;
/* open TelnetOptionHandler functionality (start) */
if (requestedWill(option) && (optionHandlers[option] != null)) {
optionHandlers[option].setWill(true);
final int[] subneg = optionHandlers[option].startSubnegotiationLocal();
if (subneg != null) {
_sendSubnegotiation(subneg);
}
}
/* open TelnetOptionHandler functionality (end) */
}
/* open TelnetOptionHandler functionality (start) */
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWont(final int option) {
options[option] &= ~WILL_MASK;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
optionHandlers[option].setWill(false);
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Sends a read char on the spy stream.
*
* @param ch - character read from the session
*/
void spyRead(final int ch) {
final OutputStream spy = spyStream;
if (spy != null) {
try {
if (ch != '\r') // never write '\r' on its own
{
if (ch == '\n') {
spy.write('\r'); // add '\r' before '\n'
}
spy.write(ch); // write original character
spy.flush();
}
} catch (final IOException e) {
spyStream = null;
}
}
}
/**
* Sends a written char on the spy stream.
*
* @param ch - character written to the session
*/
void spyWrite(final int ch) {
if (!(stateIsDo(TelnetOption.ECHO) && requestedDo(TelnetOption.ECHO))) {
final OutputStream spy = spyStream;
if (spy != null) {
try {
spy.write(ch);
spy.flush();
} catch (final IOException e) {
spyStream = null;
}
}
}
}
/* Code Section added for supporting spystreams (end) */
/**
* Looks for the state of the option.
*
* @return returns true if a do has been acknowledged
*
* @param option - option code to be looked up.
*/
boolean stateIsDo(final int option) {
return (options[option] & DO_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a dont has been acknowledged
*
* @param option - option code to be looked up.
*/
boolean stateIsDont(final int option) {
return !stateIsDo(option);
}
/**
* Looks for the state of the option.
*
* @return returns true if a will has been acknowledged
*
* @param option - option code to be looked up.
*/
boolean stateIsWill(final int option) {
return (options[option] & WILL_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a wont has been acknowledged
*
* @param option - option code to be looked up.
*/
boolean stateIsWont(final int option) {
return !stateIsWill(option);
}
/**
* Unregisters the current notification handler.
*
*/
public void unregisterNotifHandler() {
this.notifhand = null;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet/TelnetClient.java 0000664 0000000 0000000 00000033430 14340477222 0032444 0 ustar 00root root 0000000 0000000 /*
* 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.telnet;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* The TelnetClient class implements the simple network virtual terminal (NVT) for the Telnet protocol according to RFC 854. It does not implement any of the
* extra Telnet options because it is meant to be used within a Java program providing automated access to Telnet accessible resources.
*
* 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
* closing the streams.
*/
public class TelnetClient extends Telnet {
private static final int DEFAULT_MAX_SUBNEGOTIATION_LENGTH = 512;
final int maxSubnegotiationLength;
private InputStream input;
private OutputStream output;
protected boolean readerThread = true;
private TelnetInputListener inputListener;
/**
* Default TelnetClient constructor, sets terminal-type {@code VT100}.
*/
public TelnetClient() {
this("VT100", DEFAULT_MAX_SUBNEGOTIATION_LENGTH);
}
/**
* Construct an instance with the specified max subnegotiation length and the default terminal-type {@code VT100}
*
* @param maxSubnegotiationLength the size of the subnegotiation buffer
*/
public TelnetClient(final int maxSubnegotiationLength) {
this("VT100", maxSubnegotiationLength);
}
/**
* Construct an instance with the specified terminal type.
*
* @param termtype the terminal type to use, e.g. {@code VT100}
*/
public TelnetClient(final String termtype) {
this(termtype, DEFAULT_MAX_SUBNEGOTIATION_LENGTH);
}
/**
* Construct an instance with the specified terminal type and max subnegotiation length
*
* @param termtype the terminal type to use, e.g. {@code VT100}
* @param maxSubnegotiationLength the size of the subnegotiation buffer
*/
public TelnetClient(final String termtype, final int maxSubnegotiationLength) {
/* TERMINAL-TYPE option (start) */
super(termtype);
/* TERMINAL-TYPE option (end) */
this.input = null;
this.output = null;
this.maxSubnegotiationLength = maxSubnegotiationLength;
}
/**
* Handles special connection requirements.
*
* @throws IOException If an error occurs during connection setup.
*/
@Override
protected void _connectAction_() throws IOException {
super._connectAction_();
final TelnetInputStream tmp = new TelnetInputStream(_input_, this, readerThread);
if (readerThread) {
tmp.start();
}
// __input CANNOT refer to the TelnetInputStream. We run into
// blocking problems when some classes use TelnetInputStream, so
// we wrap it with a BufferedInputStream which we know is safe.
// This blocking behavior requires further investigation, but right
// now it looks like classes like InputStreamReader are not implemented
// in a safe manner.
input = new BufferedInputStream(tmp);
output = new TelnetOutputStream(this);
}
/**
* Registers a new TelnetOptionHandler for this telnet client to use.
*
* @param opthand - option handler to be registered.
*
* @throws InvalidTelnetOptionException on error
* @throws IOException on error
*/
@Override
public void addOptionHandler(final TelnetOptionHandler opthand) throws InvalidTelnetOptionException, IOException {
super.addOptionHandler(opthand);
}
/* open TelnetOptionHandler functionality (end) */
void closeOutputStream() throws IOException {
if (_output_ == null) {
return;
}
try {
_output_.close();
} finally {
_output_ = null;
}
}
/**
* Unregisters a TelnetOptionHandler.
*
* @param optcode - Code of the option to be unregistered.
*
* @throws InvalidTelnetOptionException on error
* @throws IOException on error
*/
@Override
public void deleteOptionHandler(final int optcode) throws InvalidTelnetOptionException, IOException {
super.deleteOptionHandler(optcode);
}
/**
* Disconnects the telnet session, closing the input and output streams as well as the socket. If you have references to the input and output streams of the
* telnet connection, you should not close them yourself, but rather call disconnect to properly close the connection.
*/
@Override
public void disconnect() throws IOException {
try {
if (input != null) {
input.close();
}
if (output != null) {
output.close();
}
} finally { // NET-594
output = null;
input = null;
super.disconnect();
}
}
void flushOutputStream() throws IOException {
if (_output_ == null) {
throw new IOException("Stream closed");
}
_output_.flush();
}
/**
* Returns the telnet connection input stream. You should not close the stream when you finish with it. Rather, you should call {@link #disconnect
* disconnect }.
*
* @return The telnet connection input stream.
*/
public InputStream getInputStream() {
return input;
}
/**
* Returns the state of the option on the local side.
*
* @param option - Option to be checked.
*
* @return The state of the option on the local side.
*/
public boolean getLocalOptionState(final int option) {
/* BUG (option active when not already acknowledged) (start) */
return stateIsWill(option) && requestedWill(option);
/* BUG (option active when not already acknowledged) (end) */
}
/* Code Section added for supporting AYT (start) */
/**
* Returns the telnet connection output stream. You should not close the stream when you finish with it. Rather, you should call {@link #disconnect
* disconnect }.
*
* @return The telnet connection output stream.
*/
public OutputStream getOutputStream() {
return output;
}
/**
* Gets the status of the reader thread.
*
* @return true if the reader thread is enabled, false otherwise
*/
public boolean getReaderThread() {
return readerThread;
}
/**
* Returns the state of the option on the remote side.
*
* @param option - Option to be checked.
*
* @return The state of the option on the remote side.
*/
public boolean getRemoteOptionState(final int option) {
/* BUG (option active when not already acknowledged) (start) */
return stateIsDo(option) && requestedDo(option);
/* BUG (option active when not already acknowledged) (end) */
}
/* open TelnetOptionHandler functionality (end) */
/* open TelnetOptionHandler functionality (start) */
// Notify input listener
void notifyInputListener() {
final TelnetInputListener listener;
synchronized (this) {
listener = this.inputListener;
}
if (listener != null) {
listener.telnetInputAvailable();
}
}
/**
* Register a listener to be notified when new incoming data is available to be read on the {@link #getInputStream input stream}. Only one listener is
* supported at a time.
*
*
* More precisely, notifications are issued whenever the number of bytes available for immediate reading (i.e., the value returned by
* {@link InputStream#available}) transitions from zero to non-zero. Note that (in general) multiple reads may be required to empty the buffer and reset
* this notification, because incoming bytes are being added to the internal buffer asynchronously.
*
* Notifications are only supported when a {@link #setReaderThread reader thread} is enabled for the connection.
*
* This method does not wait for any response. Messages sent by the remote end can be handled by registering an approrpriate {@link TelnetOptionHandler}.
*
* This method does not wait for any response. Subnegotiation messages sent by the remote end can be handled by registering an approrpriate
* {@link TelnetOptionHandler}.
*
* When enabled, a seaparate internal reader thread is created for new connections to read incoming data as it arrives. This results in immediate handling
* of option negotiation, notifications, etc. (at least until the fixed-size internal buffer fills up). Otherwise, no thread is created an all negotiation
* and option handling is deferred until a read() is performed on the {@link #getInputStream input stream}.
*
* The reader thread must be enabled for {@link TelnetInputListener} support.
*
* When this method is invoked, the reader thread status will apply to all subsequent connections; the current connection (if any) is not affected.
*
*
* @param code The command code of the telnet protocol command.
* @return The string representation of the telnet protocol command.
*/
public static String getCommand(final int code) {
return commandString[FIRST_COMMAND - code];
}
/**
* Determines if a given command code is valid. Returns true if valid, false if not.
*
*
* @param code The command code to test.
* @return True if the command code is valid, false if not.
**/
public static boolean isValidCommand(final int code) {
return code <= FIRST_COMMAND && code >= LAST_COMMAND;
}
// Cannot be instantiated
private TelnetCommand() {
}
}
TelnetInputListener.java 0000664 0000000 0000000 00000002364 14340477222 0033756 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* Listener interface used for notification that incoming data is available to be read.
*
* @see TelnetClient
* @since 3.0
*/
public interface TelnetInputListener {
/**
* Callback method invoked when new incoming data is available on a {@link TelnetClient}'s {@link TelnetClient#getInputStream input stream}.
*
* @see TelnetClient#registerInputListener
*/
void telnetInputAvailable();
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet/TelnetInputStream.java0000664 0000000 0000000 00000050767 14340477222 0033515 0 ustar 00root root 0000000 0000000 /*
* 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.telnet;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
final class TelnetInputStream extends BufferedInputStream implements Runnable {
/** End of file has been reached */
private static final int EOF = -1;
/** Read would block */
private static final int WOULD_BLOCK = -2;
// TODO should these be private enums?
static final int STATE_DATA = 0, STATE_IAC = 1, STATE_WILL = 2, STATE_WONT = 3, STATE_DO = 4, STATE_DONT = 5, STATE_SB = 6, STATE_SE = 7, STATE_CR = 8,
STATE_IAC_SB = 9;
private boolean hasReachedEOF; // @GuardedBy("queue")
private volatile boolean isClosed;
private boolean readIsWaiting;
private int receiveState, queueHead, queueTail, bytesAvailable;
private final int[] queue;
private final TelnetClient client;
private final Thread thread;
private IOException ioException;
/* TERMINAL-TYPE option (start) */
private final int suboption[];
private int suboptionCount;
/* TERMINAL-TYPE option (end) */
private volatile boolean threaded;
TelnetInputStream(final InputStream input, final TelnetClient client) {
this(input, client, true);
}
TelnetInputStream(final InputStream input, final TelnetClient client, final boolean readerThread) {
super(input);
this.client = client;
this.receiveState = STATE_DATA;
this.isClosed = true;
this.hasReachedEOF = false;
// Make it 2049, because when full, one slot will go unused, and we
// want a 2048 byte buffer just to have a round number (base 2 that is)
this.queue = new int[2049];
this.queueHead = 0;
this.queueTail = 0;
this.suboption = new int[client.maxSubnegotiationLength];
this.bytesAvailable = 0;
this.ioException = null;
this.readIsWaiting = false;
this.threaded = false;
if (readerThread) {
this.thread = new Thread(this);
} else {
this.thread = null;
}
}
@Override
public int available() throws IOException {
// Critical section because run() may change bytesAvailable
synchronized (queue) {
if (threaded) { // Must not call super.available when running threaded: NET-466
return bytesAvailable;
}
return bytesAvailable + super.available();
}
}
// Cannot be synchronized. Will cause deadlock if run() is blocked
// in read because BufferedInputStream read() is synchronized.
@Override
public void close() throws IOException {
// Completely disregard the fact thread may still be running.
// We can't afford to block on this close by waiting for
// thread to terminate because few if any JVM's will actually
// interrupt a system read() from the interrupt() method.
super.close();
synchronized (queue) {
hasReachedEOF = true;
isClosed = true;
if (thread != null && thread.isAlive()) {
thread.interrupt();
}
queue.notifyAll();
}
}
/** Returns false. Mark is not supported. */
@Override
public boolean markSupported() {
return false;
}
// synchronized(client) critical sections are to protect against
// TelnetOutputStream writing through the telnet client at same time
// as a processDo/Will/etc. command invoked from TelnetInputStream
// tries to write. Returns true if buffer was previously empty.
private boolean processChar(final int ch) throws InterruptedException {
// Critical section because we're altering bytesAvailable,
// queueTail, and the contents of _queue.
final boolean bufferWasEmpty;
synchronized (queue) {
bufferWasEmpty = bytesAvailable == 0;
while (bytesAvailable >= queue.length - 1) {
// The queue is full. We need to wait before adding any more data to it. Hopefully the stream owner
// will consume some data soon!
if (!threaded) {
// We've been asked to add another character to the queue, but it is already full and there's
// no other thread to drain it. This should not have happened!
throw new IllegalStateException("Queue is full! Cannot process another character.");
}
queue.notify();
try {
queue.wait();
} catch (final InterruptedException e) {
throw e;
}
}
// Need to do this in case we're not full, but block on a read
if (readIsWaiting && threaded) {
queue.notify();
}
queue[queueTail] = ch;
++bytesAvailable;
if (++queueTail >= queue.length) {
queueTail = 0;
}
}
return bufferWasEmpty;
}
@Override
public int read() throws IOException {
// Critical section because we're altering bytesAvailable,
// queueHead, and the contents of _queue in addition to
// testing value of hasReachedEOF.
synchronized (queue) {
while (true) {
if (ioException != null) {
final IOException e;
e = ioException;
ioException = null;
throw e;
}
if (bytesAvailable == 0) {
// Return EOF if at end of file
if (hasReachedEOF) {
return EOF;
}
// Otherwise, we have to wait for queue to get something
if (threaded) {
queue.notify();
try {
readIsWaiting = true;
queue.wait();
readIsWaiting = false;
} catch (final InterruptedException e) {
throw new InterruptedIOException("Fatal thread interruption during read.");
}
} else {
// alreadyread = false;
readIsWaiting = true;
int ch;
boolean mayBlock = true; // block on the first read only
do {
try {
if ((ch = read(mayBlock)) < 0) { // must be EOF
if (ch != WOULD_BLOCK) {
return ch;
}
}
} catch (final InterruptedIOException e) {
synchronized (queue) {
ioException = e;
queue.notifyAll();
try {
queue.wait(100);
} catch (final InterruptedException interrupted) {
// Ignored
}
}
return EOF;
}
try {
if (ch != WOULD_BLOCK) {
processChar(ch);
}
} catch (final InterruptedException e) {
if (isClosed) {
return EOF;
}
}
// Reads should not block on subsequent iterations. Potentially, this could happen if the
// remaining buffered socket data consists entirely of Telnet command sequence and no "user" data.
mayBlock = false;
}
// Continue reading as long as there is data available and the queue is not full.
while (super.available() > 0 && bytesAvailable < queue.length - 1);
readIsWaiting = false;
}
continue;
}
final int ch;
ch = queue[queueHead];
if (++queueHead >= queue.length) {
queueHead = 0;
}
--bytesAvailable;
// Need to explicitly notify() so available() works properly
if (bytesAvailable == 0 && threaded) {
queue.notify();
}
return ch;
}
}
}
// synchronized(client) critical sections are to protect against
// TelnetOutputStream writing through the telnet client at same time
// as a processDo/Will/etc. command invoked from TelnetInputStream
// tries to write.
/**
* Get the next byte of data. IAC commands are processed internally and do not return data.
*
* @param mayBlock true if method is allowed to block
* @return the next byte of data, or -1 (EOF) if end of stread reached, or -2 (WOULD_BLOCK) if mayBlock is false and there is no data available
*/
private int read(final boolean mayBlock) throws IOException {
int ch;
while (true) {
// If there is no more data AND we were told not to block,
// just return WOULD_BLOCK (-2). (More efficient than exception.)
if (!mayBlock && super.available() == 0) {
return WOULD_BLOCK;
}
// Otherwise, exit only when we reach end of stream.
if ((ch = super.read()) < 0) {
return EOF;
}
ch = ch & 0xff;
/* Code Section added for supporting AYT (start) */
synchronized (client) {
client.processAYTResponse();
}
/* Code Section added for supporting AYT (end) */
/* Code Section added for supporting spystreams (start) */
client.spyRead(ch);
/* Code Section added for supporting spystreams (end) */
switch (receiveState) {
case STATE_CR:
if (ch == '\0') {
// Strip null
continue;
}
// How do we handle newline after cr?
// else if (ch == '\n' && _requestedDont(TelnetOption.ECHO) &&
// Handle as normal data by falling through to _STATE_DATA case
//$FALL-THROUGH$
case STATE_DATA:
if (ch == TelnetCommand.IAC) {
receiveState = STATE_IAC;
continue;
}
if (ch == '\r') {
synchronized (client) {
if (client.requestedDont(TelnetOption.BINARY)) {
receiveState = STATE_CR;
} else {
receiveState = STATE_DATA;
}
}
} else {
receiveState = STATE_DATA;
}
break;
case STATE_IAC:
switch (ch) {
case TelnetCommand.WILL:
receiveState = STATE_WILL;
continue;
case TelnetCommand.WONT:
receiveState = STATE_WONT;
continue;
case TelnetCommand.DO:
receiveState = STATE_DO;
continue;
case TelnetCommand.DONT:
receiveState = STATE_DONT;
continue;
/* TERMINAL-TYPE option (start) */
case TelnetCommand.SB:
suboptionCount = 0;
receiveState = STATE_SB;
continue;
/* TERMINAL-TYPE option (end) */
case TelnetCommand.IAC:
receiveState = STATE_DATA;
break; // exit to enclosing switch to return IAC from read
case TelnetCommand.SE: // unexpected byte! ignore it (don't send it as a command)
receiveState = STATE_DATA;
continue;
default:
receiveState = STATE_DATA;
client.processCommand(ch); // Notify the user
continue; // move on the next char
}
break; // exit and return from read
case STATE_WILL:
synchronized (client) {
client.processWill(ch);
client.flushOutputStream();
}
receiveState = STATE_DATA;
continue;
case STATE_WONT:
synchronized (client) {
client.processWont(ch);
client.flushOutputStream();
}
receiveState = STATE_DATA;
continue;
case STATE_DO:
synchronized (client) {
client.processDo(ch);
client.flushOutputStream();
}
receiveState = STATE_DATA;
continue;
case STATE_DONT:
synchronized (client) {
client.processDont(ch);
client.flushOutputStream();
}
receiveState = STATE_DATA;
continue;
/* TERMINAL-TYPE option (start) */
case STATE_SB:
switch (ch) {
case TelnetCommand.IAC:
receiveState = STATE_IAC_SB;
continue;
default:
// store suboption char
if (suboptionCount < suboption.length) {
suboption[suboptionCount++] = ch;
}
break;
}
receiveState = STATE_SB;
continue;
case STATE_IAC_SB: // IAC received during SB phase
switch (ch) {
case TelnetCommand.SE:
synchronized (client) {
client.processSuboption(suboption, suboptionCount);
client.flushOutputStream();
}
receiveState = STATE_DATA;
continue;
case TelnetCommand.IAC: // De-dup the duplicated IAC
if (suboptionCount < suboption.length) {
suboption[suboptionCount++] = ch;
}
break;
default: // unexpected byte! ignore it
break;
}
receiveState = STATE_SB;
continue;
/* TERMINAL-TYPE option (end) */
}
break;
}
return ch;
}
/**
* Reads the next number of bytes from the stream into an array and returns the number of bytes read. Returns -1 if the end of the stream has been reached.
*
*
* @param buffer The byte array in which to store the data.
* @return The number of bytes read. Returns -1 if the end of the message has been reached.
* @throws IOException If an error occurs in reading the underlying stream.
*/
@Override
public int read(final byte buffer[]) throws IOException {
return read(buffer, 0, buffer.length);
}
/**
* Reads the next number of bytes from the stream into an array and returns the number of bytes read. Returns -1 if the end of the message has been reached.
* The characters are stored in the array starting from the given offset and up to the length specified.
*
*
* @param buffer The byte array in which to store the data.
* @param offset The offset into the array at which to start storing data.
* @param length The number of bytes to read.
* @return The number of bytes read. Returns -1 if the end of the stream has been reached.
* @throws IOException If an error occurs while reading the underlying stream.
*/
@Override
public int read(final byte buffer[], int offset, int length) throws IOException {
int ch;
final int off;
if (length < 1) {
return 0;
}
// Critical section because run() may change bytesAvailable
synchronized (queue) {
if (length > bytesAvailable) {
length = bytesAvailable;
}
}
if ((ch = read()) == EOF) {
return EOF;
}
off = offset;
do {
buffer[offset++] = (byte) ch;
} while (--length > 0 && (ch = read()) != EOF);
// client._spyRead(buffer, off, offset - off);
return offset - off;
}
@Override
public void run() {
int ch;
try {
_outerLoop: while (!isClosed) {
try {
if ((ch = read(true)) < 0) {
break;
}
} catch (final InterruptedIOException e) {
synchronized (queue) {
ioException = e;
queue.notifyAll();
try {
queue.wait(100);
} catch (final InterruptedException interrupted) {
if (isClosed) {
break _outerLoop;
}
}
continue;
}
} catch (final RuntimeException re) {
// We treat any runtime exceptions as though the
// stream has been closed. We close the
// underlying stream just to be sure.
super.close();
// Breaking the loop has the effect of setting
// the state to closed at the end of the method.
break _outerLoop;
}
// Process new character
boolean notify = false;
try {
notify = processChar(ch);
} catch (final InterruptedException e) {
if (isClosed) {
break _outerLoop;
}
}
// Notify input listener if buffer was previously empty
if (notify) {
client.notifyInputListener();
}
}
} catch (final IOException ioe) {
synchronized (queue) {
ioException = ioe;
}
client.notifyInputListener();
}
synchronized (queue) {
isClosed = true; // Possibly redundant
hasReachedEOF = true;
queue.notify();
}
threaded = false;
}
void start() {
if (thread == null) {
return;
}
int priority;
isClosed = false;
// TODO remove this
// Need to set a higher priority in case JVM does not use pre-emptive
// threads. This should prevent scheduler induced deadlock (rather than
// deadlock caused by a bug in this code).
priority = Thread.currentThread().getPriority() + 1;
if (priority > Thread.MAX_PRIORITY) {
priority = Thread.MAX_PRIORITY;
}
thread.setPriority(priority);
thread.setDaemon(true);
thread.start();
threaded = true; // tell _processChar that we are running threaded
}
}
TelnetNotificationHandler.java 0000664 0000000 0000000 00000004147 14340477222 0035076 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* The TelnetNotificationHandler interface can be used to handle notification of options negotiation commands received on a telnet session.
*
* The user can implement this interface and register a TelnetNotificationHandler by using the registerNotificationHandler() of TelnetClient to be notified of
* option negotiation commands.
*/
public interface TelnetNotificationHandler {
/**
* The remote party sent a DO command.
*/
int RECEIVED_DO = 1;
/**
* The remote party sent a DONT command.
*/
int RECEIVED_DONT = 2;
/**
* The remote party sent a WILL command.
*/
int RECEIVED_WILL = 3;
/**
* The remote party sent a WONT command.
*/
int RECEIVED_WONT = 4;
/**
* The remote party sent a COMMAND.
*
* @since 2.2
*/
int RECEIVED_COMMAND = 5;
/**
* Callback method called when TelnetClient receives an command or option negotiation command
*
* @param negotiation_code - type of (negotiation) command received (RECEIVED_DO, RECEIVED_DONT, RECEIVED_WILL, RECEIVED_WONT, RECEIVED_COMMAND)
*
* @param option_code - code of the option negotiated, or the command code itself (e.g. NOP).
*/
void receivedNegotiation(int negotiation_code, int option_code);
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet/TelnetOption.java 0000664 0000000 0000000 00000014022 14340477222 0032472 0 ustar 00root root 0000000 0000000 /*
* 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.telnet;
/**
* The TelnetOption class cannot be instantiated and only serves as a storehouse for telnet option constants.
*
* Details regarding Telnet option specification can be found in RFC 855.
*
*
* @see org.apache.commons.net.telnet.Telnet
* @see org.apache.commons.net.telnet.TelnetClient
*/
public class TelnetOption {
/** The maximum value an option code can have. This value is 255. */
public static final int MAX_OPTION_VALUE = 255;
public static final int BINARY = 0;
public static final int ECHO = 1;
public static final int PREPARE_TO_RECONNECT = 2;
public static final int SUPPRESS_GO_AHEAD = 3;
public static final int APPROXIMATE_MESSAGE_SIZE = 4;
public static final int STATUS = 5;
public static final int TIMING_MARK = 6;
public static final int REMOTE_CONTROLLED_TRANSMISSION = 7;
public static final int NEGOTIATE_OUTPUT_LINE_WIDTH = 8;
public static final int NEGOTIATE_OUTPUT_PAGE_SIZE = 9;
public static final int NEGOTIATE_CARRIAGE_RETURN = 10;
public static final int NEGOTIATE_HORIZONTAL_TAB_STOP = 11;
public static final int NEGOTIATE_HORIZONTAL_TAB = 12;
public static final int NEGOTIATE_FORMFEED = 13;
public static final int NEGOTIATE_VERTICAL_TAB_STOP = 14;
public static final int NEGOTIATE_VERTICAL_TAB = 15;
public static final int NEGOTIATE_LINEFEED = 16;
public static final int EXTENDED_ASCII = 17;
public static final int FORCE_LOGOUT = 18;
public static final int BYTE_MACRO = 19;
public static final int DATA_ENTRY_TERMINAL = 20;
public static final int SUPDUP = 21;
public static final int SUPDUP_OUTPUT = 22;
public static final int SEND_LOCATION = 23;
public static final int TERMINAL_TYPE = 24;
public static final int END_OF_RECORD = 25;
public static final int TACACS_USER_IDENTIFICATION = 26;
public static final int OUTPUT_MARKING = 27;
public static final int TERMINAL_LOCATION_NUMBER = 28;
public static final int REGIME_3270 = 29;
public static final int X3_PAD = 30;
public static final int WINDOW_SIZE = 31;
public static final int TERMINAL_SPEED = 32;
public static final int REMOTE_FLOW_CONTROL = 33;
public static final int LINEMODE = 34;
public static final int X_DISPLAY_LOCATION = 35;
public static final int OLD_ENVIRONMENT_VARIABLES = 36;
public static final int AUTHENTICATION = 37;
public static final int ENCRYPTION = 38;
public static final int NEW_ENVIRONMENT_VARIABLES = 39;
public static final int EXTENDED_OPTIONS_LIST = 255;
@SuppressWarnings("unused")
private static final int FIRST_OPTION = BINARY;
private static final int LAST_OPTION = EXTENDED_OPTIONS_LIST;
private static final String optionString[] = { "BINARY", "ECHO", "RCP", "SUPPRESS GO AHEAD", "NAME", "STATUS", "TIMING MARK", "RCTE", "NAOL", "NAOP",
"NAOCRD", "NAOHTS", "NAOHTD", "NAOFFD", "NAOVTS", "NAOVTD", "NAOLFD", "EXTEND ASCII", "LOGOUT", "BYTE MACRO", "DATA ENTRY TERMINAL", "SUPDUP",
"SUPDUP OUTPUT", "SEND LOCATION", "TERMINAL TYPE", "END OF RECORD", "TACACS UID", "OUTPUT MARKING", "TTYLOC", "3270 REGIME", "X.3 PAD", "NAWS",
"TSPEED", "LFLOW", "LINEMODE", "XDISPLOC", "OLD-ENVIRON", "AUTHENTICATION", "ENCRYPT", "NEW-ENVIRON", "TN3270E", "XAUTH", "CHARSET", "RSP",
"Com Port Control", "Suppress Local Echo", "Start TLS", "KERMIT", "SEND-URL", "FORWARD_X", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"TELOPT PRAGMA LOGON", "TELOPT SSPI LOGON", "TELOPT PRAGMA HEARTBEAT", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Extended-Options-List" };
/**
* Returns the string representation of the telnet protocol option corresponding to the given option code.
*
* @param code The option code of the telnet protocol option
* @return The string representation of the telnet protocol option.
*/
public static final String getOption(final int code) {
if (optionString[code].isEmpty()) {
return "UNASSIGNED";
}
return optionString[code];
}
/**
* Determines if a given option code is valid. Returns true if valid, false if not.
*
* @param code The option code to test.
* @return True if the option code is valid, false if not.
**/
public static final boolean isValidOption(final int code) {
return code <= LAST_OPTION;
}
// Cannot be instantiated
private TelnetOption() {
}
}
TelnetOptionHandler.java 0000664 0000000 0000000 00000020420 14340477222 0033710 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* The TelnetOptionHandler class is the base class to be used for implementing handlers for telnet options.
*
* TelnetOptionHandler implements basic option handling functionality and defines abstract methods that must be implemented to define subnegotiation behavior.
*/
public abstract class TelnetOptionHandler {
/**
* Option code
*/
private int optionCode = -1;
/**
* true if the option should be activated on the local side
*/
private boolean initialLocal;
/**
* true if the option should be activated on the remote side
*/
private boolean initialRemote;
/**
* true if the option should be accepted on the local side
*/
private boolean acceptLocal;
/**
* true if the option should be accepted on the remote side
*/
private boolean acceptRemote;
/**
* true if the option is active on the local side
*/
private boolean doFlag;
/**
* true if the option is active on the remote side
*/
private boolean willFlag;
/**
* Constructor for the TelnetOptionHandler. Allows defining desired initial setting for local/remote activation of this option and behavior in case a
* local/remote activation request for this option is received.
*
*
* @param optcode - Option code.
* @param initlocal - if set to true, a WILL is sent upon connection.
* @param initremote - if set to true, a DO is sent upon connection.
* @param acceptlocal - if set to true, any DO request is accepted.
* @param acceptremote - if set to true, any WILL request is accepted.
*/
public TelnetOptionHandler(final int optcode, final boolean initlocal, final boolean initremote, final boolean acceptlocal, final boolean acceptremote) {
optionCode = optcode;
initialLocal = initlocal;
initialRemote = initremote;
acceptLocal = acceptlocal;
acceptRemote = acceptremote;
}
/**
* Method called upon reception of a subnegotiation for this option coming from the other end.
*
* This implementation returns null, and must be overridden by the actual TelnetOptionHandler to specify which response must be sent for the subnegotiation
* request.
*
*
* @param suboptionData - the sequence received, without IAC SB & IAC SE
* @param suboptionLength - the length of data in suboption_data
*
* @return response to be sent to the subnegotiation sequence. TelnetClient will add IAC SB & IAC SE. null means no response
*/
public int[] answerSubnegotiation(final int suboptionData[], final int suboptionLength) {
return null;
}
/**
* Returns a boolean indicating whether to accept a DO request coming from the other end.
*
*
* @return true if a DO request shall be accepted.
*/
public boolean getAcceptLocal() {
return acceptLocal;
}
/**
* Returns a boolean indicating whether to accept a WILL request coming from the other end.
*
*
* @return true if a WILL request shall be accepted.
*/
public boolean getAcceptRemote() {
return acceptRemote;
}
/**
* Returns a boolean indicating whether a DO request sent to the other side has been acknowledged.
*
*
* @return true if a DO sent to the other side has been acknowledged.
*/
boolean getDo() {
return doFlag;
}
/**
* Returns a boolean indicating whether to send a WILL request to the other end upon connection.
*
*
* @return true if a WILL request shall be sent upon connection.
*/
public boolean getInitLocal() {
return initialLocal;
}
/**
* Returns a boolean indicating whether to send a DO request to the other end upon connection.
*
*
* @return true if a DO request shall be sent upon connection.
*/
public boolean getInitRemote() {
return initialRemote;
}
/**
* Returns the option code for this option.
*
*
* @return Option code.
*/
public int getOptionCode() {
return optionCode;
}
/**
* Returns a boolean indicating whether a WILL request sent to the other side has been acknowledged.
*
*
* @return true if a WILL sent to the other side has been acknowledged.
*/
boolean getWill() {
return willFlag;
}
/**
* Set behavior of the option for DO requests coming from the other end.
*
*
* @param accept - if true, subsequent DO requests will be accepted.
*/
public void setAcceptLocal(final boolean accept) {
acceptLocal = accept;
}
/**
* Set behavior of the option for WILL requests coming from the other end.
*
*
* @param accept - if true, subsequent WILL requests will be accepted.
*/
public void setAcceptRemote(final boolean accept) {
acceptRemote = accept;
}
/**
* Tells this option whether a DO request sent to the other side has been acknowledged (invoked by TelnetClient).
*
*
* @param state - if true, a DO request has been acknowledged.
*/
void setDo(final boolean state) {
doFlag = state;
}
/**
* Tells this option whether to send a WILL request upon connection.
*
*
* @param init - if true, a WILL request will be sent upon subsequent connections.
*/
public void setInitLocal(final boolean init) {
initialLocal = init;
}
/**
* Tells this option whether to send a DO request upon connection.
*
*
* @param init - if true, a DO request will be sent upon subsequent connections.
*/
public void setInitRemote(final boolean init) {
initialRemote = init;
}
/**
* Tells this option whether a WILL request sent to the other side has been acknowledged (invoked by TelnetClient).
*
*
* @param state - if true, a WILL request has been acknowledged.
*/
void setWill(final boolean state) {
willFlag = state;
}
/**
* This method is invoked whenever this option is acknowledged active on the local end (TelnetClient sent a WILL, remote side sent a DO). The method is used
* to specify a subnegotiation sequence that will be sent by TelnetClient when the option is activated.
*
* This implementation returns null, and must be overriden by the actual TelnetOptionHandler to specify which response must be sent for the subnegotiation
* request.
*
* @return subnegotiation sequence to be sent by TelnetClient. TelnetClient will add IAC SB & IAC SE. null means no subnegotiation.
*/
public int[] startSubnegotiationLocal() {
return null;
}
/**
* This method is invoked whenever this option is acknowledged active on the remote end (TelnetClient sent a DO, remote side sent a WILL). The method is
* used to specify a subnegotiation sequence that will be sent by TelnetClient when the option is activated.
*
* This implementation returns null, and must be overriden by the actual TelnetOptionHandler to specify which response must be sent for the subnegotiation
* request.
*
* @return subnegotiation sequence to be sent by TelnetClient. TelnetClient will add IAC SB & IAC SE. null means no subnegotiation.
*/
public int[] startSubnegotiationRemote() {
return null;
}
}
TelnetOutputStream.java 0000664 0000000 0000000 00000011265 14340477222 0033625 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
import java.io.IOException;
import java.io.OutputStream;
/**
* Wraps an output stream.
*
* In binary mode, the only conversion is to double IAC.
*
* In ASCII mode, if convertCRtoCRLF is true (currently always true), any CR is converted to CRLF. IACs are doubled. Also a bare LF is converted to CRLF and a
* bare CR is converted to CR\0
*
*/
final class TelnetOutputStream extends OutputStream {
private final TelnetClient client;
// TODO there does not appear to be any way to change this value - should it be a ctor parameter?
private final boolean convertCRtoCRLF = true;
private boolean lastWasCR;
TelnetOutputStream(final TelnetClient client) {
this.client = client;
}
/** Closes the stream. */
@Override
public void close() throws IOException {
client.closeOutputStream();
}
/** Flushes the stream. */
@Override
public void flush() throws IOException {
client.flushOutputStream();
}
/**
* Writes a byte array to the stream.
*
*
* @param buffer The byte array to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public void write(final byte buffer[]) throws IOException {
write(buffer, 0, buffer.length);
}
/**
* Writes a number of bytes from a byte array to the stream starting from a given offset.
*
*
* @param buffer The byte array to write.
* @param offset The offset into the array at which to start copying data.
* @param length The number of bytes to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public void write(final byte buffer[], int offset, int length) throws IOException {
synchronized (client) {
while (length-- > 0) {
write(buffer[offset++]);
}
}
}
/**
* Writes a byte to the stream.
*
*
* @param ch The byte to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public void write(int ch) throws IOException {
synchronized (client) {
ch &= 0xff;
if (client.requestedWont(TelnetOption.BINARY)) // i.e. ASCII
{
if (lastWasCR) {
if (convertCRtoCRLF) {
client.sendByte('\n');
if (ch == '\n') // i.e. was CRLF anyway
{
lastWasCR = false;
return;
}
} // __convertCRtoCRLF
else if (ch != '\n') {
client.sendByte('\0'); // RFC854 requires CR NUL for bare CR
}
}
switch (ch) {
case '\r':
client.sendByte('\r');
lastWasCR = true;
break;
case '\n':
if (!lastWasCR) { // convert LF to CRLF
client.sendByte('\r');
}
client.sendByte(ch);
lastWasCR = false;
break;
case TelnetCommand.IAC:
client.sendByte(TelnetCommand.IAC);
client.sendByte(TelnetCommand.IAC);
lastWasCR = false;
break;
default:
client.sendByte(ch);
lastWasCR = false;
break;
}
} // end ASCII
else if (ch == TelnetCommand.IAC) {
client.sendByte(ch);
client.sendByte(TelnetCommand.IAC);
} else {
client.sendByte(ch);
}
}
}
}
TerminalTypeOptionHandler.java 0000664 0000000 0000000 00000007133 14340477222 0035100 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* Implements the telnet terminal type option RFC 1091.
*/
public class TerminalTypeOptionHandler extends TelnetOptionHandler {
/**
* Terminal type option
*/
protected static final int TERMINAL_TYPE = 24;
/**
* Send (for subnegotiation)
*/
protected static final int TERMINAL_TYPE_SEND = 1;
/**
* Is (for subnegotiation)
*/
protected static final int TERMINAL_TYPE_IS = 0;
/**
* Terminal type
*/
private final String termType;
/**
* Constructor for the TerminalTypeOptionHandler. Initial and accept behavior flags are set to false
*
*
* @param termtype - terminal type that will be negotiated.
*/
public TerminalTypeOptionHandler(final String termtype) {
super(TelnetOption.TERMINAL_TYPE, false, false, false, false);
termType = termtype;
}
/**
* Constructor for the TerminalTypeOptionHandler. Allows defining desired initial setting for local/remote activation of this option and behavior in case a
* local/remote activation request for this option is received.
*
*
* @param termtype - terminal type that will be negotiated.
* @param initlocal - if set to true, a WILL is sent upon connection.
* @param initremote - if set to true, a DO is sent upon connection.
* @param acceptlocal - if set to true, any DO request is accepted.
* @param acceptremote - if set to true, any WILL request is accepted.
*/
public TerminalTypeOptionHandler(final String termtype, final boolean initlocal, final boolean initremote, final boolean acceptlocal,
final boolean acceptremote) {
super(TelnetOption.TERMINAL_TYPE, initlocal, initremote, acceptlocal, acceptremote);
termType = termtype;
}
/**
* Implements the abstract method of TelnetOptionHandler.
*
*
* @param suboptionData - the sequence received, without IAC SB & IAC SE
* @param suboptionLength - the length of data in suboption_data
*
* @return terminal type information
*/
@Override
public int[] answerSubnegotiation(final int suboptionData[], final int suboptionLength) {
if ((suboptionData != null) && (suboptionLength > 1) && (termType != null)) {
if ((suboptionData[0] == TERMINAL_TYPE) && (suboptionData[1] == TERMINAL_TYPE_SEND)) {
final int response[] = new int[termType.length() + 2];
response[0] = TERMINAL_TYPE;
response[1] = TERMINAL_TYPE_IS;
for (int ii = 0; ii < termType.length(); ii++) {
response[ii + 2] = termType.charAt(ii);
}
return response;
}
}
return null;
}
}
WindowSizeOptionHandler.java 0000664 0000000 0000000 00000010132 14340477222 0034556 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet /*
* 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.telnet;
/**
* Implements the telnet window size option RFC 1073.
*
* @since 2.0
*/
public class WindowSizeOptionHandler extends TelnetOptionHandler {
/**
* Window size option
*/
protected static final int WINDOW_SIZE = 31;
/**
* Horizontal Size
*/
private int width = 80;
/**
* Vertical Size
*/
private int height = 24;
/**
* Constructor for the WindowSizeOptionHandler. Initial and accept behavior flags are set to false
*
*
* @param nWidth - Window width.
* @param nHeight - Window Height
*/
public WindowSizeOptionHandler(final int nWidth, final int nHeight) {
super(TelnetOption.WINDOW_SIZE, false, false, false, false);
width = nWidth;
height = nHeight;
}
/**
* Constructor for the WindowSizeOptionHandler. Allows defining desired initial setting for local/remote activation of this option and behavior in case a
* local/remote activation request for this option is received.
*
*
* @param nWidth - Window width.
* @param nHeight - Window Height
* @param initlocal - if set to true, a WILL is sent upon connection.
* @param initremote - if set to true, a DO is sent upon connection.
* @param acceptlocal - if set to true, any DO request is accepted.
* @param acceptremote - if set to true, any WILL request is accepted.
*/
public WindowSizeOptionHandler(final int nWidth, final int nHeight, final boolean initlocal, final boolean initremote, final boolean acceptlocal,
final boolean acceptremote) {
super(TelnetOption.WINDOW_SIZE, initlocal, initremote, acceptlocal, acceptremote);
width = nWidth;
height = nHeight;
}
/**
* Implements the abstract method of TelnetOptionHandler. This will send the client Height and Width to the server.
*
*
* @return array to send to remote system
*/
@Override
public int[] startSubnegotiationLocal() {
final int nCompoundWindowSize = width * 0x10000 + height;
int nResponseSize = 5;
int nIndex;
int nShift;
int nTurnedOnBits;
if (width % 0x100 == 0xFF) {
nResponseSize += 1;
}
if (width / 0x100 == 0xFF) {
nResponseSize += 1;
}
if (height % 0x100 == 0xFF) {
nResponseSize += 1;
}
if (height / 0x100 == 0xFF) {
nResponseSize += 1;
}
//
// allocate response array
//
final int response[] = new int[nResponseSize];
//
// Build response array.
// ---------------------
// 1. put option name.
// 2. loop through Window size and fill the values,
// 3. duplicate 'ff' if needed.
//
response[0] = WINDOW_SIZE; // 1 //
for ( // 2 //
nIndex = 1, nShift = 24; nIndex < nResponseSize; nIndex++, nShift -= 8) {
nTurnedOnBits = 0xFF;
nTurnedOnBits <<= nShift;
response[nIndex] = (nCompoundWindowSize & nTurnedOnBits) >>> nShift;
if (response[nIndex] == 0xff) { // 3 //
nIndex++;
response[nIndex] = 0xff;
}
}
return response;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/telnet/package-info.java 0000664 0000000 0000000 00000001553 14340477222 0032377 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Telnet implementation
*/
package org.apache.commons.net.telnet; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/ 0000775 0000000 0000000 00000000000 14340477222 0026666 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTP.java 0000664 0000000 0000000 00000026155 14340477222 0030317 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.DatagramPacket;
import java.net.SocketException;
import org.apache.commons.net.DatagramSocketClient;
/**
* The TFTP class exposes a set of methods to allow you to deal with the TFTP protocol directly, in case you want to write your own TFTP client or server.
* However, almost every user should only be concerend with the {@link org.apache.commons.net.DatagramSocketClient#open open() }, and
* {@link org.apache.commons.net.DatagramSocketClient#close close() }, methods. Additionally,the a
* {@link org.apache.commons.net.DatagramSocketClient#setDefaultTimeout setDefaultTimeout() } method may be of importance for performance tuning.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals.
*
*
* @see org.apache.commons.net.DatagramSocketClient
* @see TFTPPacket
* @see TFTPPacketException
* @see TFTPClient
*/
public class TFTP extends DatagramSocketClient {
/**
* The ascii transfer mode. Its value is 0 and equivalent to NETASCII_MODE
*/
public static final int ASCII_MODE = 0;
/**
* The netascii transfer mode. Its value is 0.
*/
public static final int NETASCII_MODE = 0;
/**
* The binary transfer mode. Its value is 1 and equivalent to OCTET_MODE.
*/
public static final int BINARY_MODE = 1;
/**
* The image transfer mode. Its value is 1 and equivalent to OCTET_MODE.
*/
public static final int IMAGE_MODE = 1;
/**
* The octet transfer mode. Its value is 1.
*/
public static final int OCTET_MODE = 1;
/**
* The default number of milliseconds to wait to receive a datagram before timing out. The default is 5000 milliseconds (5 seconds).
*/
public static final int DEFAULT_TIMEOUT = 5000;
/**
* The default TFTP port according to RFC 783 is 69.
*/
public static final int DEFAULT_PORT = 69;
/**
* The size to use for TFTP packet buffers. Its 4 plus the TFTPPacket.SEGMENT_SIZE, i.e. 516.
*/
static final int PACKET_SIZE = TFTPPacket.SEGMENT_SIZE + 4;
/**
* Returns the TFTP string representation of a TFTP transfer mode. Will throw an ArrayIndexOutOfBoundsException if an invalid transfer mode is specified.
*
* @param mode The TFTP transfer mode. One of the MODE constants.
* @return The TFTP string representation of the TFTP transfer mode.
*/
public static final String getModeName(final int mode) {
return TFTPRequestPacket.modeStrings[mode];
}
/** A buffer used to accelerate receives in bufferedReceive() */
private byte[] receiveBuffer;
/** A datagram used to minimize memory allocation in bufferedReceive() */
private DatagramPacket receiveDatagram;
/** A datagram used to minimize memory allocation in bufferedSend() */
private DatagramPacket sendDatagram;
/**
* A buffer used to accelerate sends in bufferedSend(). It is left package visible so that TFTPClient may be slightly more efficient during file sends. It
* saves the creation of an additional buffer and prevents a buffer copy in _newDataPcket().
*/
byte[] sendBuffer;
/**
* Creates a TFTP instance with a default timeout of DEFAULT_TIMEOUT, a null socket, and buffered operations disabled.
*/
public TFTP() {
setDefaultTimeout(DEFAULT_TIMEOUT);
receiveBuffer = null;
receiveDatagram = null;
}
/**
* Initializes the internal buffers. Buffers are used by {@link #bufferedSend bufferedSend() } and {@link #bufferedReceive bufferedReceive() }. This method
* must be called before calling either one of those two methods. When you finish using buffered operations, you must call {@link #endBufferedOps
* endBufferedOps() }.
*/
public final void beginBufferedOps() {
receiveBuffer = new byte[PACKET_SIZE];
receiveDatagram = new DatagramPacket(receiveBuffer, receiveBuffer.length);
sendBuffer = new byte[PACKET_SIZE];
sendDatagram = new DatagramPacket(sendBuffer, sendBuffer.length);
}
/**
* This is a special method to perform a more efficient packet receive. It should only be used after calling {@link #beginBufferedOps beginBufferedOps() }.
* beginBufferedOps() initializes a set of buffers used internally that prevent the new allocation of a DatagramPacket and byte array for each send and
* receive. To use these buffers you must call the bufferedReceive() and bufferedSend() methods instead of send() and receive(). You must also be certain
* that you don't manipulate the resulting packet in such a way that it interferes with future buffered operations. For example, a TFTPDataPacket received
* with bufferedReceive() will have a reference to the internal byte buffer. You must finish using this data before calling bufferedReceive() again, or else
* the data will be overwritten by the the call.
*
* @return The TFTPPacket received.
* @throws InterruptedIOException If a socket timeout occurs. The Java documentation claims an InterruptedIOException is thrown on a DatagramSocket timeout,
* but in practice we find a SocketException is thrown. You should catch both to be safe.
* @throws SocketException If a socket timeout occurs. The Java documentation claims an InterruptedIOException is thrown on a DatagramSocket timeout,
* but in practice we find a SocketException is thrown. You should catch both to be safe.
* @throws IOException If some other I/O error occurs.
* @throws TFTPPacketException If an invalid TFTP packet is received.
*/
public final TFTPPacket bufferedReceive() throws IOException, InterruptedIOException, SocketException, TFTPPacketException {
receiveDatagram.setData(receiveBuffer);
receiveDatagram.setLength(receiveBuffer.length);
_socket_.receive(receiveDatagram);
final TFTPPacket newTFTPPacket = TFTPPacket.newTFTPPacket(receiveDatagram);
trace("<", newTFTPPacket);
return newTFTPPacket;
}
/**
* This is a special method to perform a more efficient packet send. It should only be used after calling {@link #beginBufferedOps beginBufferedOps() }.
* beginBufferedOps() initializes a set of buffers used internally that prevent the new allocation of a DatagramPacket and byte array for each send and
* receive. To use these buffers you must call the bufferedReceive() and bufferedSend() methods instead of send() and receive(). You must also be certain
* that you don't manipulate the resulting packet in such a way that it interferes with future buffered operations. For example, a TFTPDataPacket received
* with bufferedReceive() will have a reference to the internal byte buffer. You must finish using this data before calling bufferedReceive() again, or else
* the data will be overwritten by the the call.
*
* @param packet The TFTP packet to send.
* @throws IOException If some I/O error occurs.
*/
public final void bufferedSend(final TFTPPacket packet) throws IOException {
trace(">", packet);
_socket_.send(packet.newDatagram(sendDatagram, sendBuffer));
}
/**
* This method synchronizes a connection by discarding all packets that may be in the local socket buffer. This method need only be called when you
* implement your own TFTP client or server.
*
* @throws IOException if an I/O error occurs.
*/
public final void discardPackets() throws IOException {
final int to;
final DatagramPacket datagram;
datagram = new DatagramPacket(new byte[PACKET_SIZE], PACKET_SIZE);
to = getSoTimeout();
setSoTimeout(1);
try {
while (true) {
_socket_.receive(datagram);
}
} catch (final SocketException | InterruptedIOException e) {
// Do nothing. We timed out so we hope we're caught up.
}
setSoTimeout(to);
}
/**
* Releases the resources used to perform buffered sends and receives.
*/
public final void endBufferedOps() {
receiveBuffer = null;
receiveDatagram = null;
sendBuffer = null;
sendDatagram = null;
}
/**
* Receives a TFTPPacket.
*
* @return The TFTPPacket received.
* @throws InterruptedIOException If a socket timeout occurs. The Java documentation claims an InterruptedIOException is thrown on a DatagramSocket timeout,
* but in practice we find a SocketException is thrown. You should catch both to be safe.
* @throws SocketException If a socket timeout occurs. The Java documentation claims an InterruptedIOException is thrown on a DatagramSocket timeout,
* but in practice we find a SocketException is thrown. You should catch both to be safe.
* @throws IOException If some other I/O error occurs.
* @throws TFTPPacketException If an invalid TFTP packet is received.
*/
public final TFTPPacket receive() throws IOException, InterruptedIOException, SocketException, TFTPPacketException {
final DatagramPacket packet;
packet = new DatagramPacket(new byte[PACKET_SIZE], PACKET_SIZE);
_socket_.receive(packet);
final TFTPPacket newTFTPPacket = TFTPPacket.newTFTPPacket(packet);
trace("<", newTFTPPacket);
return newTFTPPacket;
}
/**
* Sends a TFTP packet to its destination.
*
* @param packet The TFTP packet to send.
* @throws IOException If some I/O error occurs.
*/
public final void send(final TFTPPacket packet) throws IOException {
trace(">", packet);
_socket_.send(packet.newDatagram());
}
/**
* Trace facility; this implementation does nothing.
*
* Override it to trace the data, for example:
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
* should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
* receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
*
* @see TFTPPacket
* @see TFTPPacketException
* @see TFTP
*/
public final class TFTPAckPacket extends TFTPPacket {
/** The block number being acknowledged by the packet. */
int blockNumber;
/**
* Creates an acknowledgement packet based from a received datagram. Assumes the datagram is at least length 4, else an ArrayIndexOutOfBoundsException may
* be thrown.
*
* @param datagram The datagram containing the received acknowledgement.
* @throws TFTPPacketException If the datagram isn't a valid TFTP acknowledgement packet.
*/
TFTPAckPacket(final DatagramPacket datagram) throws TFTPPacketException {
super(TFTPPacket.ACKNOWLEDGEMENT, datagram.getAddress(), datagram.getPort());
final byte[] data;
data = datagram.getData();
if (getType() != data[1]) {
throw new TFTPPacketException("TFTP operator code does not match type.");
}
this.blockNumber = (((data[2] & 0xff) << 8) | (data[3] & 0xff));
}
/**
* Creates an acknowledgment packet to be sent to a host at a given port acknowledging receipt of a block.
*
* @param destination The host to which the packet is going to be sent.
* @param port The port to which the packet is going to be sent.
* @param blockNumber The block number being acknowledged.
*/
public TFTPAckPacket(final InetAddress destination, final int port, final int blockNumber) {
super(TFTPPacket.ACKNOWLEDGEMENT, destination, port);
this.blockNumber = blockNumber;
}
/**
* Returns the block number of the acknowledgement.
*
* @return The block number of the acknowledgement.
*/
public int getBlockNumber() {
return blockNumber;
}
/**
* Creates a UDP datagram containing all the TFTP acknowledgement packet data in the proper format. This is a method exposed to the programmer in case he
* wants to implement his own TFTP client instead of using the {@link org.apache.commons.net.tftp.TFTPClient} class. Under normal circumstances, you should
* not have a need to call this method.
*
* @return A UDP datagram containing the TFTP acknowledgement packet.
*/
@Override
public DatagramPacket newDatagram() {
final byte[] data;
data = new byte[4];
data[0] = 0;
data[1] = (byte) type;
data[2] = (byte) ((blockNumber & 0xffff) >> 8);
data[3] = (byte) (blockNumber & 0xff);
return new DatagramPacket(data, data.length, address, port);
}
/**
* This is a method only available within the package for implementing efficient datagram transport by elminating buffering. It takes a datagram as an
* argument, and a byte buffer in which to store the raw datagram data. Inside the method, the data is set as the datagram's data and the datagram returned.
*
* @param datagram The datagram to create.
* @param data The buffer to store the packet and to use in the datagram.
* @return The datagram argument.
*/
@Override
DatagramPacket newDatagram(final DatagramPacket datagram, final byte[] data) {
data[0] = 0;
data[1] = (byte) type;
data[2] = (byte) ((blockNumber & 0xffff) >> 8);
data[3] = (byte) (blockNumber & 0xff);
datagram.setAddress(address);
datagram.setPort(port);
datagram.setData(data);
datagram.setLength(4);
return datagram;
}
/**
* Sets the block number of the acknowledgement.
*
* @param blockNumber the number to set
*/
public void setBlockNumber(final int blockNumber) {
this.blockNumber = blockNumber;
}
/**
* For debugging
*
* @since 3.6
*/
@Override
public String toString() {
return super.toString() + " ACK " + blockNumber;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTPClient.java 0000664 0000000 0000000 00000055377 14340477222 0031466 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import org.apache.commons.net.io.FromNetASCIIOutputStream;
import org.apache.commons.net.io.ToNetASCIIInputStream;
/**
* The TFTPClient class encapsulates all the aspects of the TFTP protocol necessary to receive and send files through TFTP. It is derived from the
* {@link org.apache.commons.net.tftp.TFTP} because it is more convenient than using aggregation, and as a result exposes the same set of methods to allow you
* to deal with the TFTP protocol directly. However, almost every user should only be concerend with the the
* {@link org.apache.commons.net.DatagramSocketClient#open open() }, {@link org.apache.commons.net.DatagramSocketClient#close close() }, {@link #sendFile
* sendFile() }, and {@link #receiveFile receiveFile() } methods. Additionally, the {@link #setMaxTimeouts setMaxTimeouts() } and
* {@link org.apache.commons.net.DatagramSocketClient#setDefaultTimeout setDefaultTimeout() } methods may be of importance for performance tuning.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals.
*
*
* @see TFTP
* @see TFTPPacket
* @see TFTPPacketException
*/
public class TFTPClient extends TFTP {
/**
* The default number of times a receive attempt is allowed to timeout before ending attempts to retry the receive and failing. The default is 5 timeouts.
*/
public static final int DEFAULT_MAX_TIMEOUTS = 5;
/** The maximum number of timeouts allowed before failing. */
private int maxTimeouts;
/** The number of bytes received in the ongoing download. */
private long totalBytesReceived;
/** The number of bytes sent in the ongoing upload. */
private long totalBytesSent;
/**
* Creates a TFTPClient instance with a default timeout of DEFAULT_TIMEOUT, maximum timeouts value of DEFAULT_MAX_TIMEOUTS, a null socket, and buffered
* operations disabled.
*/
public TFTPClient() {
maxTimeouts = DEFAULT_MAX_TIMEOUTS;
}
/**
* Returns the maximum number of times a receive attempt is allowed to timeout before ending attempts to retry the receive and failing.
*
* @return The maximum number of timeouts allowed.
*/
public int getMaxTimeouts() {
return maxTimeouts;
}
/**
* @return The number of bytes received in the ongoing download
*/
public long getTotalBytesReceived() {
return totalBytesReceived;
}
/**
* @return The number of bytes sent in the ongoing download
*/
public long getTotalBytesSent() {
return totalBytesSent;
}
/**
* Same as calling receiveFile(fileName, mode, output, host, TFTP.DEFAULT_PORT).
*
* @param fileName The name of the file to receive.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param output The OutputStream to which the file should be written.
* @param host The remote host serving the file.
* @return number of bytes read
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
*/
public int receiveFile(final String fileName, final int mode, final OutputStream output, final InetAddress host) throws IOException {
return receiveFile(fileName, mode, output, host, DEFAULT_PORT);
}
/**
* Requests a named file from a remote host, writes the file to an OutputStream, closes the connection, and returns the number of bytes read. A local UDP
* socket must first be created by {@link org.apache.commons.net.DatagramSocketClient#open open()} before invoking this method. This method will not close
* the OutputStream containing the file; you must close it after the method invocation.
*
* @param fileName The name of the file to receive.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param output The OutputStream to which the file should be written.
* @param host The remote host serving the file.
* @param port The port number of the remote TFTP server.
* @return number of bytes read
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
*/
public int receiveFile(final String fileName, final int mode, OutputStream output, InetAddress host, final int port) throws IOException {
int bytesRead = 0;
int lastBlock = 0;
int block = 1;
int hostPort = 0;
int dataLength = 0;
totalBytesReceived = 0;
if (mode == TFTP.ASCII_MODE) {
output = new FromNetASCIIOutputStream(output);
}
TFTPPacket sent = new TFTPReadRequestPacket(host, port, fileName, mode);
final TFTPAckPacket ack = new TFTPAckPacket(host, port, 0);
beginBufferedOps();
boolean justStarted = true;
try {
do { // while more data to fetch
bufferedSend(sent); // start the fetch/send an ack
boolean wantReply = true;
int timeouts = 0;
do { // until successful response
try {
final TFTPPacket received = bufferedReceive();
// The first time we receive we get the port number and
// answering host address (for hosts with multiple IPs)
final int recdPort = received.getPort();
final InetAddress recdAddress = received.getAddress();
if (justStarted) {
justStarted = false;
if (recdPort == port) { // must not use the control port here
final TFTPErrorPacket error = new TFTPErrorPacket(recdAddress, recdPort, TFTPErrorPacket.UNKNOWN_TID, "INCORRECT SOURCE PORT");
bufferedSend(error);
throw new IOException("Incorrect source port (" + recdPort + ") in request reply.");
}
hostPort = recdPort;
ack.setPort(hostPort);
if (!host.equals(recdAddress)) {
host = recdAddress;
ack.setAddress(host);
sent.setAddress(host);
}
}
// Comply with RFC 783 indication that an error acknowledgment
// should be sent to originator if unexpected TID or host.
if (host.equals(recdAddress) && recdPort == hostPort) {
switch (received.getType()) {
case TFTPPacket.ERROR:
TFTPErrorPacket error = (TFTPErrorPacket) received;
throw new IOException("Error code " + error.getError() + " received: " + error.getMessage());
case TFTPPacket.DATA:
final TFTPDataPacket data = (TFTPDataPacket) received;
dataLength = data.getDataLength();
lastBlock = data.getBlockNumber();
if (lastBlock == block) { // is the next block number?
try {
output.write(data.getData(), data.getDataOffset(), dataLength);
} catch (final IOException e) {
error = new TFTPErrorPacket(host, hostPort, TFTPErrorPacket.OUT_OF_SPACE, "File write failed.");
bufferedSend(error);
throw e;
}
++block;
if (block > 65535) {
// wrap the block number
block = 0;
}
wantReply = false; // got the next block, drop out to ack it
} else { // unexpected block number
discardPackets();
if (lastBlock == (block == 0 ? 65535 : block - 1)) {
wantReply = false; // Resend last acknowledgemen
}
}
break;
default:
throw new IOException("Received unexpected packet type (" + received.getType() + ")");
}
} else { // incorrect host or TID
final TFTPErrorPacket error = new TFTPErrorPacket(recdAddress, recdPort, TFTPErrorPacket.UNKNOWN_TID, "Unexpected host or port.");
bufferedSend(error);
}
} catch (final SocketException | InterruptedIOException e) {
if (++timeouts >= maxTimeouts) {
throw new IOException("Connection timed out.");
}
} catch (final TFTPPacketException e) {
throw new IOException("Bad packet: " + e.getMessage());
}
} while (wantReply); // waiting for response
ack.setBlockNumber(lastBlock);
sent = ack;
bytesRead += dataLength;
totalBytesReceived += dataLength;
} while (dataLength == TFTPPacket.SEGMENT_SIZE); // not eof
bufferedSend(sent); // send the final ack
} finally {
endBufferedOps();
}
return bytesRead;
}
/**
* Same as calling receiveFile(fileName, mode, output, hostname, TFTP.DEFAULT_PORT).
*
* @param fileName The name of the file to receive.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param output The OutputStream to which the file should be written.
* @param hostname The name of the remote host serving the file.
* @return number of bytes read
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
* @throws UnknownHostException If the hostname cannot be resolved.
*/
public int receiveFile(final String fileName, final int mode, final OutputStream output, final String hostname) throws UnknownHostException, IOException {
return receiveFile(fileName, mode, output, InetAddress.getByName(hostname), DEFAULT_PORT);
}
/**
* Requests a named file from a remote host, writes the file to an OutputStream, closes the connection, and returns the number of bytes read. A local UDP
* socket must first be created by {@link org.apache.commons.net.DatagramSocketClient#open open()} before invoking this method. This method will not close
* the OutputStream containing the file; you must close it after the method invocation.
*
* @param fileName The name of the file to receive.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param output The OutputStream to which the file should be written.
* @param hostname The name of the remote host serving the file.
* @param port The port number of the remote TFTP server.
* @return number of bytes read
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
* @throws UnknownHostException If the hostname cannot be resolved.
*/
public int receiveFile(final String fileName, final int mode, final OutputStream output, final String hostname, final int port)
throws UnknownHostException, IOException {
return receiveFile(fileName, mode, output, InetAddress.getByName(hostname), port);
}
/**
* Same as calling sendFile(fileName, mode, input, host, TFTP.DEFAULT_PORT).
*
* @param fileName The name the remote server should use when creating the file on its file system.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param input the input stream containing the data to be sent
* @param host The name of the remote host receiving the file.
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
* @throws UnknownHostException If the hostname cannot be resolved.
*/
public void sendFile(final String fileName, final int mode, final InputStream input, final InetAddress host) throws IOException {
sendFile(fileName, mode, input, host, DEFAULT_PORT);
}
/**
* Requests to send a file to a remote host, reads the file from an InputStream, sends the file to the remote host, and closes the connection. A local UDP
* socket must first be created by {@link org.apache.commons.net.DatagramSocketClient#open open()} before invoking this method. This method will not close
* the InputStream containing the file; you must close it after the method invocation.
*
* @param fileName The name the remote server should use when creating the file on its file system.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param input the input stream containing the data to be sent
* @param host The remote host receiving the file.
* @param port The port number of the remote TFTP server.
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
*/
public void sendFile(final String fileName, final int mode, InputStream input, InetAddress host, final int port) throws IOException {
int block = 0;
int hostPort = 0;
boolean justStarted = true;
boolean lastAckWait = false;
totalBytesSent = 0L;
if (mode == TFTP.ASCII_MODE) {
input = new ToNetASCIIInputStream(input);
}
TFTPPacket sent = new TFTPWriteRequestPacket(host, port, fileName, mode);
final TFTPDataPacket data = new TFTPDataPacket(host, port, 0, sendBuffer, 4, 0);
beginBufferedOps();
try {
do { // until eof
// first time: block is 0, lastBlock is 0, send a request packet.
// subsequent: block is integer starting at 1, send data packet.
bufferedSend(sent);
boolean wantReply = true;
int timeouts = 0;
do {
try {
final TFTPPacket received = bufferedReceive();
final InetAddress recdAddress = received.getAddress();
final int recdPort = received.getPort();
// The first time we receive we get the port number and
// answering host address (for hosts with multiple IPs)
if (justStarted) {
justStarted = false;
if (recdPort == port) { // must not use the control port here
final TFTPErrorPacket error = new TFTPErrorPacket(recdAddress, recdPort, TFTPErrorPacket.UNKNOWN_TID, "INCORRECT SOURCE PORT");
bufferedSend(error);
throw new IOException("Incorrect source port (" + recdPort + ") in request reply.");
}
hostPort = recdPort;
data.setPort(hostPort);
if (!host.equals(recdAddress)) {
host = recdAddress;
data.setAddress(host);
sent.setAddress(host);
}
}
// Comply with RFC 783 indication that an error acknowledgment
// should be sent to originator if unexpected TID or host.
if (host.equals(recdAddress) && recdPort == hostPort) {
switch (received.getType()) {
case TFTPPacket.ERROR:
final TFTPErrorPacket error = (TFTPErrorPacket) received;
throw new IOException("Error code " + error.getError() + " received: " + error.getMessage());
case TFTPPacket.ACKNOWLEDGEMENT:
final int lastBlock = ((TFTPAckPacket) received).getBlockNumber();
if (lastBlock == block) {
++block;
if (block > 65535) {
// wrap the block number
block = 0;
}
wantReply = false; // got the ack we want
} else {
discardPackets();
}
break;
default:
throw new IOException("Received unexpected packet type.");
}
} else { // wrong host or TID; send error
final TFTPErrorPacket error = new TFTPErrorPacket(recdAddress, recdPort, TFTPErrorPacket.UNKNOWN_TID, "Unexpected host or port.");
bufferedSend(error);
}
} catch (final SocketException | InterruptedIOException e) {
if (++timeouts >= maxTimeouts) {
throw new IOException("Connection timed out.");
}
} catch (final TFTPPacketException e) {
throw new IOException("Bad packet: " + e.getMessage());
}
// retry until a good ack
} while (wantReply);
if (lastAckWait) {
break; // we were waiting for this; now all done
}
int dataLength = TFTPPacket.SEGMENT_SIZE;
int offset = 4;
int totalThisPacket = 0;
int bytesRead = 0;
while (dataLength > 0 && (bytesRead = input.read(sendBuffer, offset, dataLength)) > 0) {
offset += bytesRead;
dataLength -= bytesRead;
totalThisPacket += bytesRead;
}
if (totalThisPacket < TFTPPacket.SEGMENT_SIZE) {
/* this will be our last packet -- send, wait for ack, stop */
lastAckWait = true;
}
data.setBlockNumber(block);
data.setData(sendBuffer, 4, totalThisPacket);
sent = data;
totalBytesSent += totalThisPacket;
} while (true); // loops until after lastAckWait is set
} finally {
endBufferedOps();
}
}
/**
* Same as calling sendFile(fileName, mode, input, hostname, TFTP.DEFAULT_PORT).
*
* @param fileName The name the remote server should use when creating the file on its file system.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param input the input stream containing the data to be sent
* @param hostname The name of the remote host receiving the file.
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
* @throws UnknownHostException If the hostname cannot be resolved.
*/
public void sendFile(final String fileName, final int mode, final InputStream input, final String hostname) throws UnknownHostException, IOException {
sendFile(fileName, mode, input, InetAddress.getByName(hostname), DEFAULT_PORT);
}
/**
* Requests to send a file to a remote host, reads the file from an InputStream, sends the file to the remote host, and closes the connection. A local UDP
* socket must first be created by {@link org.apache.commons.net.DatagramSocketClient#open open()} before invoking this method. This method will not close
* the InputStream containing the file; you must close it after the method invocation.
*
* @param fileName The name the remote server should use when creating the file on its file system.
* @param mode The TFTP mode of the transfer (one of the MODE constants).
* @param input the input stream containing the data to be sent
* @param hostname The name of the remote host receiving the file.
* @param port The port number of the remote TFTP server.
* @throws IOException If an I/O error occurs. The nature of the error will be reported in the message.
* @throws UnknownHostException If the hostname cannot be resolved.
*/
public void sendFile(final String fileName, final int mode, final InputStream input, final String hostname, final int port)
throws UnknownHostException, IOException {
sendFile(fileName, mode, input, InetAddress.getByName(hostname), port);
}
/**
* Sets the maximum number of times a receive attempt is allowed to timeout during a receiveFile() or sendFile() operation before ending attempts to retry
* the receive and failing. The default is DEFAULT_MAX_TIMEOUTS.
*
* @param numTimeouts The maximum number of timeouts to allow. Values less than 1 should not be used, but if they are, they are treated as 1.
*/
public void setMaxTimeouts(final int numTimeouts) {
maxTimeouts = Math.max(numTimeouts, 1);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTPDataPacket.java 0000664 0000000 0000000 00000017702 14340477222 0032237 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/**
* A final class derived from TFTPPacket definiing the TFTP Data packet type.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
* should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
* receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
*
* @see TFTPPacket
* @see TFTPPacketException
* @see TFTP
*/
public final class TFTPDataPacket extends TFTPPacket {
/** The maximum number of bytes in a TFTP data packet (512) */
public static final int MAX_DATA_LENGTH = 512;
/** The minimum number of bytes in a TFTP data packet (0) */
public static final int MIN_DATA_LENGTH = 0;
/** The block number of the packet. */
int blockNumber;
/** The length of the data. */
private int length;
/** The offset into the _data array at which the data begins. */
private int offset;
/** The data stored in the packet. */
private byte[] data;
/**
* Creates a data packet based from a received datagram. Assumes the datagram is at least length 4, else an ArrayIndexOutOfBoundsException may be thrown.
*
* @param datagram The datagram containing the received data.
* @throws TFTPPacketException If the datagram isn't a valid TFTP data packet.
*/
TFTPDataPacket(final DatagramPacket datagram) throws TFTPPacketException {
super(TFTPPacket.DATA, datagram.getAddress(), datagram.getPort());
this.data = datagram.getData();
this.offset = 4;
if (getType() != this.data[1]) {
throw new TFTPPacketException("TFTP operator code does not match type.");
}
this.blockNumber = (((this.data[2] & 0xff) << 8) | (this.data[3] & 0xff));
this.length = datagram.getLength() - 4;
if (this.length > MAX_DATA_LENGTH) {
this.length = MAX_DATA_LENGTH;
}
}
public TFTPDataPacket(final InetAddress destination, final int port, final int blockNumber, final byte[] data) {
this(destination, port, blockNumber, data, 0, data.length);
}
/**
* Creates a data packet to be sent to a host at a given port with a given block number. The actual data to be sent is passed as an array, an offset, and a
* length. The offset is the offset into the byte array where the data starts. The length is the length of the data. If the length is greater than
* MAX_DATA_LENGTH, it is truncated.
*
* @param destination The host to which the packet is going to be sent.
* @param port The port to which the packet is going to be sent.
* @param blockNumber The block number of the data.
* @param data The byte array containing the data.
* @param offset The offset into the array where the data starts.
* @param length The length of the data.
*/
public TFTPDataPacket(final InetAddress destination, final int port, final int blockNumber, final byte[] data, final int offset, final int length) {
super(TFTPPacket.DATA, destination, port);
this.blockNumber = blockNumber;
this.data = data;
this.offset = offset;
this.length = Math.min(length, MAX_DATA_LENGTH);
}
/**
* Returns the block number of the data packet.
*
* @return The block number of the data packet.
*/
public int getBlockNumber() {
return blockNumber;
}
/**
* Returns the byte array containing the packet data.
*
* @return The byte array containing the packet data.
*/
public byte[] getData() {
return data;
}
/**
* Returns the length of the data part of the data packet.
*
* @return The length of the data part of the data packet.
*/
public int getDataLength() {
return length;
}
/**
* Returns the offset into the byte array where the packet data actually starts.
*
* @return The offset into the byte array where the packet data actually starts.
*/
public int getDataOffset() {
return offset;
}
/**
* Creates a UDP datagram containing all the TFTP data packet data in the proper format. This is a method exposed to the programmer in case he wants to
* implement his own TFTP client instead of using the {@link org.apache.commons.net.tftp.TFTPClient} class. Under normal circumstances, you should not have
* a need to call this method.
*
* @return A UDP datagram containing the TFTP data packet.
*/
@Override
public DatagramPacket newDatagram() {
final byte[] data;
data = new byte[length + 4];
data[0] = 0;
data[1] = (byte) type;
data[2] = (byte) ((blockNumber & 0xffff) >> 8);
data[3] = (byte) (blockNumber & 0xff);
System.arraycopy(this.data, offset, data, 4, length);
return new DatagramPacket(data, length + 4, address, port);
}
/**
* This is a method only available within the package for implementing efficient datagram transport by elminating buffering. It takes a datagram as an
* argument, and a byte buffer in which to store the raw datagram data. Inside the method, the data is set as the datagram's data and the datagram returned.
*
* @param datagram The datagram to create.
* @param data The buffer to store the packet and to use in the datagram.
* @return The datagram argument.
*/
@Override
DatagramPacket newDatagram(final DatagramPacket datagram, final byte[] data) {
data[0] = 0;
data[1] = (byte) type;
data[2] = (byte) ((blockNumber & 0xffff) >> 8);
data[3] = (byte) (blockNumber & 0xff);
// Doublecheck we're not the same
if (data != this.data) {
System.arraycopy(this.data, offset, data, 4, length);
}
datagram.setAddress(address);
datagram.setPort(port);
datagram.setData(data);
datagram.setLength(length + 4);
return datagram;
}
/**
* Sets the block number of the data packet.
*
* @param blockNumber the number to set
*/
public void setBlockNumber(final int blockNumber) {
this.blockNumber = blockNumber;
}
/**
* Sets the data for the data packet.
*
* @param data The byte array containing the data.
* @param offset The offset into the array where the data starts.
* @param length The length of the data.
*/
public void setData(final byte[] data, final int offset, final int length) {
this.data = data;
this.offset = offset;
this.length = length;
this.length = Math.min(length, MAX_DATA_LENGTH);
}
/**
* For debugging
*
* @since 3.6
*/
@Override
public String toString() {
return super.toString() + " DATA " + blockNumber + " " + length;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTPErrorPacket.java 0000664 0000000 0000000 00000016053 14340477222 0032455 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/**
* A final class derived from TFTPPacket definiing the TFTP Error packet type.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
* should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
* receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
*
* @see TFTPPacket
* @see TFTPPacketException
* @see TFTP
*/
public final class TFTPErrorPacket extends TFTPPacket {
/** The undefined error code according to RFC 783, value 0. */
public static final int UNDEFINED = 0;
/** The file not found error code according to RFC 783, value 1. */
public static final int FILE_NOT_FOUND = 1;
/** The access violation error code according to RFC 783, value 2. */
public static final int ACCESS_VIOLATION = 2;
/** The disk full error code according to RFC 783, value 3. */
public static final int OUT_OF_SPACE = 3;
/**
* The illegal TFTP operation error code according to RFC 783, value 4.
*/
public static final int ILLEGAL_OPERATION = 4;
/** The unknown transfer id error code according to RFC 783, value 5. */
public static final int UNKNOWN_TID = 5;
/** The file already exists error code according to RFC 783, value 6. */
public static final int FILE_EXISTS = 6;
/** The no such user error code according to RFC 783, value 7. */
public static final int NO_SUCH_USER = 7;
/** The error code of this packet. */
private final int error;
/** The error message of this packet. */
private final String message;
/**
* Creates an error packet based from a received datagram. Assumes the datagram is at least length 4, else an ArrayIndexOutOfBoundsException may be thrown.
*
* @param datagram The datagram containing the received error.
* @throws TFTPPacketException If the datagram isn't a valid TFTP error packet.
*/
TFTPErrorPacket(final DatagramPacket datagram) throws TFTPPacketException {
super(TFTPPacket.ERROR, datagram.getAddress(), datagram.getPort());
int index;
final int length;
final byte[] data;
final StringBuilder buffer;
data = datagram.getData();
length = datagram.getLength();
if (getType() != data[1]) {
throw new TFTPPacketException("TFTP operator code does not match type.");
}
error = (data[2] & 0xff) << 8 | data[3] & 0xff;
if (length < 5) {
throw new TFTPPacketException("Bad error packet. No message.");
}
index = 4;
buffer = new StringBuilder();
while (index < length && data[index] != 0) {
buffer.append((char) data[index]);
++index;
}
message = buffer.toString();
}
/**
* Creates an error packet to be sent to a host at a given port with an error code and error message.
*
* @param destination The host to which the packet is going to be sent.
* @param port The port to which the packet is going to be sent.
* @param error The error code of the packet.
* @param message The error message of the packet.
*/
public TFTPErrorPacket(final InetAddress destination, final int port, final int error, final String message) {
super(TFTPPacket.ERROR, destination, port);
this.error = error;
this.message = message;
}
/**
* Returns the error code of the packet.
*
* @return The error code of the packet.
*/
public int getError() {
return error;
}
/**
* Returns the error message of the packet.
*
* @return The error message of the packet.
*/
public String getMessage() {
return message;
}
/**
* Creates a UDP datagram containing all the TFTP error packet data in the proper format. This is a method exposed to the programmer in case he wants to
* implement his own TFTP client instead of using the {@link org.apache.commons.net.tftp.TFTPClient} class. Under normal circumstances, you should not have
* a need to call this method.
*
* @return A UDP datagram containing the TFTP error packet.
*/
@Override
public DatagramPacket newDatagram() {
final byte[] data;
final int length;
length = message.length();
data = new byte[length + 5];
data[0] = 0;
data[1] = (byte) type;
data[2] = (byte) ((error & 0xffff) >> 8);
data[3] = (byte) (error & 0xff);
System.arraycopy(message.getBytes(), 0, data, 4, length);
data[length + 4] = 0;
return new DatagramPacket(data, data.length, address, port);
}
/**
* This is a method only available within the package for implementing efficient datagram transport by elminating buffering. It takes a datagram as an
* argument, and a byte buffer in which to store the raw datagram data. Inside the method, the data is set as the datagram's data and the datagram returned.
*
* @param datagram The datagram to create.
* @param data The buffer to store the packet and to use in the datagram.
* @return The datagram argument.
*/
@Override
DatagramPacket newDatagram(final DatagramPacket datagram, final byte[] data) {
final int length;
length = message.length();
data[0] = 0;
data[1] = (byte) type;
data[2] = (byte) ((error & 0xffff) >> 8);
data[3] = (byte) (error & 0xff);
System.arraycopy(message.getBytes(), 0, data, 4, length);
data[length + 4] = 0;
datagram.setAddress(address);
datagram.setPort(port);
datagram.setData(data);
datagram.setLength(length + 4);
return datagram;
}
/**
* For debugging
*
* @since 3.6
*/
@Override
public String toString() {
return super.toString() + " ERR " + error + " " + message;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTPPacket.java 0000664 0000000 0000000 00000017673 14340477222 0031454 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/**
* TFTPPacket is an abstract class encapsulating the functionality common to the 5 types of TFTP packets. It also provides a static factory method that will
* create the correct TFTP packet instance from a datagram. This relieves the programmer from having to figure out what kind of TFTP packet is contained in a
* datagram and create it himself.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
* should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
* receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
*
* @see TFTPPacketException
* @see TFTP
*/
public abstract class TFTPPacket {
/**
* The minimum size of a packet. This is 4 bytes. It is enough to store the opcode and blocknumber or other required data depending on the packet type.
*/
static final int MIN_PACKET_SIZE = 4;
/**
* This is the actual TFTP spec identifier and is equal to 1. Identifier returned by {@link #getType getType()} indicating a read request packet.
*/
public static final int READ_REQUEST = 1;
/**
* This is the actual TFTP spec identifier and is equal to 2. Identifier returned by {@link #getType getType()} indicating a write request packet.
*/
public static final int WRITE_REQUEST = 2;
/**
* This is the actual TFTP spec identifier and is equal to 3. Identifier returned by {@link #getType getType()} indicating a data packet.
*/
public static final int DATA = 3;
/**
* This is the actual TFTP spec identifier and is equal to 4. Identifier returned by {@link #getType getType()} indicating an acknowledgement packet.
*/
public static final int ACKNOWLEDGEMENT = 4;
/**
* This is the actual TFTP spec identifier and is equal to 5. Identifier returned by {@link #getType getType()} indicating an error packet.
*/
public static final int ERROR = 5;
/**
* The TFTP data packet maximum segment size in bytes. This is 512 and is useful for those familiar with the TFTP protocol who want to use the
* {@link org.apache.commons.net.tftp.TFTP} class methods to implement their own TFTP servers or clients.
*/
public static final int SEGMENT_SIZE = 512;
/**
* When you receive a datagram that you expect to be a TFTP packet, you use this factory method to create the proper TFTPPacket object encapsulating the
* data contained in that datagram. This method is the only way you can instantiate a TFTPPacket derived class from a datagram.
*
* @param datagram The datagram containing a TFTP packet.
* @return The TFTPPacket object corresponding to the datagram.
* @throws TFTPPacketException If the datagram does not contain a valid TFTP packet.
*/
public static final TFTPPacket newTFTPPacket(final DatagramPacket datagram) throws TFTPPacketException {
final byte[] data;
TFTPPacket packet = null;
if (datagram.getLength() < MIN_PACKET_SIZE) {
throw new TFTPPacketException("Bad packet. Datagram data length is too short.");
}
data = datagram.getData();
switch (data[1]) {
case READ_REQUEST:
packet = new TFTPReadRequestPacket(datagram);
break;
case WRITE_REQUEST:
packet = new TFTPWriteRequestPacket(datagram);
break;
case DATA:
packet = new TFTPDataPacket(datagram);
break;
case ACKNOWLEDGEMENT:
packet = new TFTPAckPacket(datagram);
break;
case ERROR:
packet = new TFTPErrorPacket(datagram);
break;
default:
throw new TFTPPacketException("Bad packet. Invalid TFTP operator code.");
}
return packet;
}
/** The type of packet. */
int type;
/** The port the packet came from or is going to. */
int port;
/** The host the packet is going to be sent or where it came from. */
InetAddress address;
/**
* This constructor is not visible outside of the package. It is used by subclasses within the package to initialize base data.
*
* @param type The type of the packet.
* @param address The host the packet came from or is going to be sent.
* @param port The port the packet came from or is going to be sent.
**/
TFTPPacket(final int type, final InetAddress address, final int port) {
this.type = type;
this.address = address;
this.port = port;
}
/**
* Returns the address of the host where the packet is going to be sent or where it came from.
*
* @return The type of the packet.
*/
public final InetAddress getAddress() {
return address;
}
/**
* Returns the port where the packet is going to be sent or where it came from.
*
* @return The port where the packet came from or where it is going.
*/
public final int getPort() {
return port;
}
/**
* Returns the type of the packet.
*
* @return The type of the packet.
*/
public final int getType() {
return type;
}
/**
* Creates a UDP datagram containing all the TFTP packet data in the proper format. This is an abstract method, exposed to the programmer in case he wants
* to implement his own TFTP client instead of using the {@link org.apache.commons.net.tftp.TFTPClient} class. Under normal circumstances, you should not
* have a need to call this method.
*
* @return A UDP datagram containing the TFTP packet.
*/
public abstract DatagramPacket newDatagram();
/**
* This is an abstract method only available within the package for implementing efficient datagram transport by elminating buffering. It takes a datagram
* as an argument, and a byte buffer in which to store the raw datagram data. Inside the method, the data should be set as the datagram's data and the
* datagram returned.
*
* @param datagram The datagram to create.
* @param data The buffer to store the packet and to use in the datagram.
* @return The datagram argument.
*/
abstract DatagramPacket newDatagram(DatagramPacket datagram, byte[] data);
/**
* Sets the host address where the packet is going to be sent.
*
* @param address the address to set
*/
public final void setAddress(final InetAddress address) {
this.address = address;
}
/**
* Sets the port where the packet is going to be sent.
*
* @param port the port to set
*/
public final void setPort(final int port) {
this.port = port;
}
/**
* For debugging
*
* @since 3.6
*/
@Override
public String toString() {
return address + " " + port + " " + type;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTPPacketException.java0000664 0000000 0000000 00000003540 14340477222 0033317 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
/**
* A class used to signify the occurrence of an error in the creation of a TFTP packet. It is not declared final so that it may be subclassed to identify more
* specific errors. You would only want to do this if you were building your own TFTP client or server on top of the {@link org.apache.commons.net.tftp.TFTP}
* class if you wanted more functionality than the {@link org.apache.commons.net.tftp.TFTPClient#receiveFile receiveFile()} and
* {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods provide.
*
*
* @see TFTPPacket
* @see TFTP
*/
public class TFTPPacketException extends Exception {
private static final long serialVersionUID = -8114699256840851439L;
/**
* Simply calls the corresponding constructor of its superclass.
*/
public TFTPPacketException() {
}
/**
* Simply calls the corresponding constructor of its superclass.
*
* @param message the message
*/
public TFTPPacketException(final String message) {
super(message);
}
}
TFTPReadRequestPacket.java 0000664 0000000 0000000 00000006160 14340477222 0033527 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp /*
* 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.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/**
* A class derived from TFTPRequestPacket definiing a TFTP read request packet type.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
* should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
* receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
*
* @see TFTPPacket
* @see TFTPRequestPacket
* @see TFTPPacketException
* @see TFTP
*/
public final class TFTPReadRequestPacket extends TFTPRequestPacket {
/**
* Creates a read request packet of based on a received datagram and assumes the datagram has already been identified as a read request. Assumes the
* datagram is at least length 4, else an ArrayIndexOutOfBoundsException may be thrown.
*
* @param datagram The datagram containing the received request.
* @throws TFTPPacketException If the datagram isn't a valid TFTP request packet.
*/
TFTPReadRequestPacket(final DatagramPacket datagram) throws TFTPPacketException {
super(TFTPPacket.READ_REQUEST, datagram);
}
/**
* Creates a read request packet to be sent to a host at a given port with a file name and transfer mode request.
*
* @param destination The host to which the packet is going to be sent.
* @param port The port to which the packet is going to be sent.
* @param fileName The requested file name.
* @param mode The requested transfer mode. This should be on of the TFTP class MODE constants (e.g., TFTP.NETASCII_MODE).
*/
public TFTPReadRequestPacket(final InetAddress destination, final int port, final String fileName, final int mode) {
super(destination, port, TFTPPacket.READ_REQUEST, fileName, mode);
}
/**
* For debugging
*
* @since 3.6
*/
@Override
public String toString() {
return super.toString() + " RRQ " + getFilename() + " " + TFTP.getModeName(getMode());
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTPRequestPacket.java 0000664 0000000 0000000 00000020034 14340477222 0033006 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/**
* An abstract class derived from TFTPPacket definiing a TFTP Request packet type. It is subclassed by the
* {@link org.apache.commons.net.tftp.TFTPReadRequestPacket} and {@link org.apache.commons.net.tftp.TFTPWriteRequestPacket} classes.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
* should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
* receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
*
* @see TFTPPacket
* @see TFTPReadRequestPacket
* @see TFTPWriteRequestPacket
* @see TFTPPacketException
* @see TFTP
*/
public abstract class TFTPRequestPacket extends TFTPPacket {
/**
* An array containing the string names of the transfer modes and indexed by the transfer mode constants.
*/
static final String[] modeStrings = { "netascii", "octet" };
/**
* A null terminated byte array representation of the ascii names of the transfer mode constants. This is convenient for creating the TFTP request packets.
*/
private static final byte[] modeBytes[] = { { (byte) 'n', (byte) 'e', (byte) 't', (byte) 'a', (byte) 's', (byte) 'c', (byte) 'i', (byte) 'i', 0 },
{ (byte) 'o', (byte) 'c', (byte) 't', (byte) 'e', (byte) 't', 0 } };
/** The transfer mode of the request. */
private final int mode;
/** The file name of the request. */
private final String fileName;
/**
* Creates a request packet of a given type to be sent to a host at a given port with a file name and transfer mode request.
*
* @param destination The host to which the packet is going to be sent.
* @param port The port to which the packet is going to be sent.
* @param type The type of the request (either TFTPPacket.READ_REQUEST or TFTPPacket.WRITE_REQUEST).
* @param fileName The requested file name.
* @param mode The requested transfer mode. This should be on of the TFTP class MODE constants (e.g., TFTP.NETASCII_MODE).
*/
TFTPRequestPacket(final InetAddress destination, final int port, final int type, final String fileName, final int mode) {
super(type, destination, port);
this.fileName = fileName;
this.mode = mode;
}
/**
* Creates a request packet of a given type based on a received datagram. Assumes the datagram is at least length 4, else an ArrayIndexOutOfBoundsException
* may be thrown.
*
* @param type The type of the request (either TFTPPacket.READ_REQUEST or TFTPPacket.WRITE_REQUEST).
* @param datagram The datagram containing the received request.
* @throws TFTPPacketException If the datagram isn't a valid TFTP request packet of the appropriate type.
*/
TFTPRequestPacket(final int type, final DatagramPacket datagram) throws TFTPPacketException {
super(type, datagram.getAddress(), datagram.getPort());
final byte[] data = datagram.getData();
if (getType() != data[1]) {
throw new TFTPPacketException("TFTP operator code does not match type.");
}
final StringBuilder buffer = new StringBuilder();
int index = 2;
int length = datagram.getLength();
while (index < length && data[index] != 0) {
buffer.append((char) data[index]);
++index;
}
this.fileName = buffer.toString();
if (index >= length) {
throw new TFTPPacketException("Bad file name and mode format.");
}
buffer.setLength(0);
++index; // need to advance beyond the end of string marker
while (index < length && data[index] != 0) {
buffer.append((char) data[index]);
++index;
}
final String modeString = buffer.toString().toLowerCase(java.util.Locale.ENGLISH);
length = modeStrings.length;
int mode = 0;
for (index = 0; index < length; index++) {
if (modeString.equals(modeStrings[index])) {
mode = index;
break;
}
}
this.mode = mode;
if (index >= length) {
throw new TFTPPacketException("Unrecognized TFTP transfer mode: " + modeString);
// May just want to default to binary mode instead of throwing
// exception.
// _mode = TFTP.OCTET_MODE;
}
}
/**
* Returns the requested file name.
*
* @return The requested file name.
*/
public final String getFilename() {
return fileName;
}
/**
* Returns the transfer mode of the request.
*
* @return The transfer mode of the request.
*/
public final int getMode() {
return mode;
}
/**
* Creates a UDP datagram containing all the TFTP request packet data in the proper format. This is a method exposed to the programmer in case he wants to
* implement his own TFTP client instead of using the {@link org.apache.commons.net.tftp.TFTPClient} class. Under normal circumstances, you should not have
* a need to call this method.
*
* @return A UDP datagram containing the TFTP request packet.
*/
@Override
public final DatagramPacket newDatagram() {
final int fileLength;
final int modeLength;
final byte[] data;
fileLength = fileName.length();
modeLength = modeBytes[mode].length;
data = new byte[fileLength + modeLength + 4];
data[0] = 0;
data[1] = (byte) type;
System.arraycopy(fileName.getBytes(), 0, data, 2, fileLength);
data[fileLength + 2] = 0;
System.arraycopy(modeBytes[mode], 0, data, fileLength + 3, modeLength);
return new DatagramPacket(data, data.length, address, port);
}
/**
* This is a method only available within the package for implementing efficient datagram transport by elminating buffering. It takes a datagram as an
* argument, and a byte buffer in which to store the raw datagram data. Inside the method, the data is set as the datagram's data and the datagram returned.
*
* @param datagram The datagram to create.
* @param data The buffer to store the packet and to use in the datagram.
* @return The datagram argument.
*/
@Override
final DatagramPacket newDatagram(final DatagramPacket datagram, final byte[] data) {
final int fileLength;
final int modeLength;
fileLength = fileName.length();
modeLength = modeBytes[mode].length;
data[0] = 0;
data[1] = (byte) type;
System.arraycopy(fileName.getBytes(), 0, data, 2, fileLength);
data[fileLength + 2] = 0;
System.arraycopy(modeBytes[mode], 0, data, fileLength + 3, modeLength);
datagram.setAddress(address);
datagram.setPort(port);
datagram.setData(data);
datagram.setLength(fileLength + modeLength + 3);
return datagram;
}
}
TFTPWriteRequestPacket.java 0000664 0000000 0000000 00000006171 14340477222 0033750 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp /*
* 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.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/**
* A class derived from TFTPRequestPacket definiing a TFTP write request packet type.
*
* Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
* worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
* should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
* receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
*
* @see TFTPPacket
* @see TFTPRequestPacket
* @see TFTPPacketException
* @see TFTP
*/
public final class TFTPWriteRequestPacket extends TFTPRequestPacket {
/**
* Creates a write request packet of based on a received datagram and assumes the datagram has already been identified as a write request. Assumes the
* datagram is at least length 4, else an ArrayIndexOutOfBoundsException may be thrown.
*
* @param datagram The datagram containing the received request.
* @throws TFTPPacketException If the datagram isn't a valid TFTP request packet.
*/
TFTPWriteRequestPacket(final DatagramPacket datagram) throws TFTPPacketException {
super(TFTPPacket.WRITE_REQUEST, datagram);
}
/**
* Creates a write request packet to be sent to a host at a given port with a file name and transfer mode request.
*
* @param destination The host to which the packet is going to be sent.
* @param port The port to which the packet is going to be sent.
* @param fileName The requested file name.
* @param mode The requested transfer mode. This should be on of the TFTP class MODE constants (e.g., TFTP.NETASCII_MODE).
*/
public TFTPWriteRequestPacket(final InetAddress destination, final int port, final String fileName, final int mode) {
super(destination, port, TFTPPacket.WRITE_REQUEST, fileName, mode);
}
/**
* For debugging
*
* @since 3.6
*/
@Override
public String toString() {
return super.toString() + " WRQ " + getFilename() + " " + TFTP.getModeName(getMode());
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/package-info.java 0000664 0000000 0000000 00000001556 14340477222 0032064 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* TFTP cliemt implementation
*/
package org.apache.commons.net.tftp; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/time/ 0000775 0000000 0000000 00000000000 14340477222 0026647 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/time/TimeTCPClient.java 0000664 0000000 0000000 00000007462 14340477222 0032127 0 ustar 00root root 0000000 0000000 /*
* 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.time;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.Date;
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.
*
*
* @see TimeUDPClient
*/
public final class TimeTCPClient extends SocketClient {
/** The default time port. It is set to 37 according to RFC 868. */
public static final int DEFAULT_PORT = 37;
/**
* The number of seconds between 00:00 1 January 1900 and 00:00 1 January 1970. This value can be useful for converting time values to other formats.
*/
public static final long SECONDS_1900_TO_1970 = 2208988800L;
/**
* The default TimeTCPClient constructor. It merely sets the default port to
* 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
* 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
* This class implements section 6.8. Base64 Content-Transfer-Encoding from RFC 2045 Multipurpose Internet Mail Extensions (MIME) Part One:
* Format of Internet Message Bodies by Freed and Borenstein.
*
* The class can be parameterized in the following manner with various constructors:
*
* Since this class operates directly on byte streams, and not character streams, it is hard-coded to only encode/decode character encodings which are
* compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252, UTF-8, etc).
*
* The {@value} character limit does not count the trailing CRLF, but counts all other characters, including any equal signs.
*
* For a non-chunking version, see {@link #encodeBase64StringUnChunked(byte[])}.
*
* @param binaryData binary data to encode
* @return String containing Base64 characters.
* @since 1.4
*/
public static String encodeBase64String(final byte[] binaryData) {
return newStringUtf8(encodeBase64(binaryData, true));
}
/**
* Encodes binary data using the base64 algorithm.
*
* @param binaryData binary data to encode
* @param useChunking whether to split the output into chunks
* @return String containing Base64 characters.
* @since 3.2
*/
public static String encodeBase64String(final byte[] binaryData, final boolean useChunking) {
return newStringUtf8(encodeBase64(binaryData, useChunking));
}
/**
* Encodes binary data using the base64 algorithm, without using chunking.
*
* For a chunking version, see {@link #encodeBase64String(byte[])}.
*
* @param binaryData binary data to encode
* @return String containing Base64 characters.
* @since 3.2
*/
public static String encodeBase64StringUnChunked(final byte[] binaryData) {
return newStringUtf8(encodeBase64(binaryData, false));
}
/**
* Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The url-safe variation emits - and _ instead of +
* and / characters.
*
* @param binaryData binary data to encode
* @return byte[] containing Base64 characters in their UTF-8 representation.
* @since 1.4
*/
public static byte[] encodeBase64URLSafe(final byte[] binaryData) {
return encodeBase64(binaryData, false, true);
}
/**
* Encodes binary data using a URL-safe variation of the base64 algorithm but does not chunk the output. The url-safe variation emits - and _ instead of +
* and / characters.
*
* @param binaryData binary data to encode
* @return String containing Base64 characters
* @since 1.4
*/
public static String encodeBase64URLSafeString(final byte[] binaryData) {
return newStringUtf8(encodeBase64(binaryData, false, true));
}
/**
* Encodes to a byte64-encoded integer according to crypto standards such as W3C's XML-Signature
*
* @param bigInt a BigInteger
* @return A byte array containing base64 character data
* @throws NullPointerException if null is passed in
* @since 1.4
*/
public static byte[] encodeInteger(final BigInteger bigInt) {
return encodeBase64(toIntegerBytes(bigInt), false);
}
/**
* Pre-calculates the amount of space needed to base64-encode the supplied array.
*
* @param pArray byte[] array which will later be encoded
* @param chunkSize line-length of the output (<= 0 means no chunking) between each chunkSeparator (e.g. CRLF).
* @param chunkSeparator the sequence of bytes used to separate chunks of output (e.g. CRLF).
*
* @return amount of space needed to encoded the supplied array. Returns a long since a max-len array will require Integer.MAX_VALUE + 33%.
*/
private static long getEncodeLength(final byte[] pArray, int chunkSize, final byte[] chunkSeparator) {
// base64 always encodes to multiples of 4.
chunkSize = (chunkSize / 4) * 4;
long len = (pArray.length * 4) / 3;
final long mod = len % 4;
if (mod != 0) {
len += 4 - mod;
}
if (chunkSize > 0) {
final boolean lenChunksPerfectly = len % chunkSize == 0;
len += (len / chunkSize) * chunkSeparator.length;
if (!lenChunksPerfectly) {
len += chunkSeparator.length;
}
}
return len;
}
/**
* Tests a given byte array to see if it contains only valid characters within the Base64 alphabet. Currently the method treats whitespace as valid.
*
* @param arrayOctet byte array to test
* @return
* When encoding the line length is 76, the line separator is CRLF, and the encoding table is STANDARD_ENCODE_TABLE.
*
* When decoding all variants are supported.
*
* When encoding the line length is 76, the line separator is CRLF, and the encoding table is STANDARD_ENCODE_TABLE.
*
* When decoding all variants are supported.
*
* When encoding the line length is given in the constructor, the line separator is CRLF, and the encoding table is STANDARD_ENCODE_TABLE.
*
* Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
*
* When decoding all variants are supported.
*
* When encoding the line length and line separator are given in the constructor, and the encoding table is STANDARD_ENCODE_TABLE.
*
* Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
*
* When decoding all variants are supported.
*
* When encoding the line length and line separator are given in the constructor, and the encoding table is STANDARD_ENCODE_TABLE.
*
* Line lengths that aren't multiples of 4 will still essentially end up being multiples of 4 in the encoded data.
*
* When decoding all variants are supported.
*
* Decodes all of the provided data, starting at inPos, for inAvail bytes. Should be called at least twice: once with the data to decode, and once with
* inAvail set to "-1" to alert decoder that EOF has been reached. The "-1" call is not necessary when decoding, but it doesn't hurt, either.
*
* Ignores all non-base64 characters. This is how chunked (e.g. 76 character) data is handled, since CR and LF are silently ignored, but has implications
* for other bytes, too. This method subscribes to the garbage-in, garbage-out philosophy: it will not check the provided data for validity.
*
* Thanks to "commons" project in ws.apache.org for the bitwise operations, and general approach.
* http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
*
* Encodes all of the provided data, starting at inPos, for inAvail bytes. Must be called at least twice: once with the data to encode, and once with
* inAvail set to "-1" to alert encoder that EOF has been reached, so flush last remaining bytes (if not multiple of 3).
*
* Thanks to "commons" project in ws.apache.org for the bitwise operations, and general approach.
* http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
*
* How to use with a client certificate:
*
*
* This should be the same as the default used by
* {@link javax.net.ssl.SSLContext#init(javax.net.ssl.KeyManager[], javax.net.ssl.TrustManager[], java.security.SecureRandom) SSLContext#init(KeyManager[],
* TrustManager[], SecureRandom)} when the TrustManager parameter is set to {@code null}
*
* @param keyStore the KeyStore to use, may be {@code null}
* @return the default TrustManager
* @throws GeneralSecurityException if an error occurs
*/
public static X509TrustManager getDefaultTrustManager(final KeyStore keyStore) throws GeneralSecurityException {
final String defaultAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
final TrustManagerFactory instance = TrustManagerFactory.getInstance(defaultAlgorithm);
instance.init(keyStore);
return (X509TrustManager) instance.getTrustManagers()[0];
}
/**
* Generate a TrustManager that checks server certificates for validity, but otherwise performs no checks.
*
* @return the validating TrustManager
*/
public static X509TrustManager getValidateServerCertificateTrustManager() {
return CHECK_SERVER_VALIDITY;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/util/package-info.java 0000664 0000000 0000000 00000001543 14340477222 0032060 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Utility classes
*/
package org.apache.commons.net.util; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/whois/ 0000775 0000000 0000000 00000000000 14340477222 0027042 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/whois/WhoisClient.java 0000664 0000000 0000000 00000006710 14340477222 0032141 0 ustar 00root root 0000000 0000000 /*
* 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.whois;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.net.finger.FingerClient;
/**
* The WhoisClient class implements the client side of the Internet Whois Protocol defined in RFC 954. To query a host you create a WhoisClient instance,
* connect to the host, query the host, and finally disconnect from the host. If the whois service you want to query is on a non-standard port, connect to the
* host at that port. Here's a sample use:
*
*
* FingerClient finger;
*
* finger = new FingerClient();
*
* try {
* finger.connect("foo.bar.com");
* System.out.println(finger.query("foobar", false));
* finger.disconnect();
* } catch (IOException e) {
* System.err.println("Error I/O exception: " + e.getMessage());
* return;
* }
*
*
*/
public class FingerClient extends SocketClient {
/**
* The default FINGER port. Set to 79 according to RFC 1288.
*/
public static final int DEFAULT_PORT = 79;
private static final String LONG_FLAG = "/W ";
private final transient char[] buffer = new char[1024];
/**
* The default FingerClient constructor. Initializes the default port to DEFAULT_PORT .
*/
public FingerClient() {
setDefaultPort(DEFAULT_PORT);
}
/**
* Fingers the connected host and returns the input stream from the network connection of the finger query. This is equivalent to calling
* getInputStream(longOutput, ""). You must first connect to a finger server before calling this method, and you should disconnect after finishing reading
* the stream.
*
* @param longOutput Set to true if long output is requested, false if not.
* @return The InputStream of the network connection of the finger query. Can be read to obtain finger results.
* @throws IOException If an I/O error during the operation.
*/
public InputStream getInputStream(final boolean longOutput) throws IOException {
return getInputStream(longOutput, "");
}
/**
* Fingers a user and returns the input stream from the network connection of the finger query. You must first connect to a finger server before calling
* this method, and you should disconnect after finishing reading the stream.
*
* @param longOutput Set to true if long output is requested, false if not.
* @param username The name of the user to finger.
* @return The InputStream of the network connection of the finger query. Can be read to obtain finger results.
* @throws IOException If an I/O error during the operation.
*/
public InputStream getInputStream(final boolean longOutput, final String username) throws IOException {
return getInputStream(longOutput, username, null);
}
/**
* Fingers a user and returns the input stream from the network connection of the finger query. You must first connect to a finger server before calling
* this method, and you should disconnect after finishing reading the stream.
*
* @param longOutput Set to true if long output is requested, false if not.
* @param username The name of the user to finger.
* @param encoding the character encoding that should be used for the query, null for the platform's default encoding
* @return The InputStream of the network connection of the finger query. Can be read to obtain finger results.
* @throws IOException If an I/O error during the operation.
*/
public InputStream getInputStream(final boolean longOutput, final String username, final String encoding) throws IOException {
final DataOutputStream output;
final StringBuilder buffer = new StringBuilder(64);
if (longOutput) {
buffer.append(LONG_FLAG);
}
buffer.append(username);
buffer.append(SocketClient.NETASCII_EOL);
// Note: Charsets.toCharset() returns the platform default for null input
final byte[] encodedQuery = buffer.toString().getBytes(Charsets.toCharset(encoding).name()); // Java 1.6 can use
// charset directly
output = new DataOutputStream(new BufferedOutputStream(_output_, 1024));
output.write(encodedQuery, 0, encodedQuery.length);
output.flush();
return _input_;
}
/**
* Fingers the connected host and returns the output as a String. You must first connect to a finger server before calling this method, and you should
* disconnect afterward. This is equivalent to calling query(longOutput, "") .
*
* @param longOutput Set to true if long output is requested, false if not.
* @return The result of the finger query.
* @throws IOException If an I/O error occurs while reading the socket.
*/
public String query(final boolean longOutput) throws IOException {
return query(longOutput, "");
}
/**
* Fingers a user at the connected host and returns the output as a String. You must first connect to a finger server before calling this method, and you
* should disconnect afterward.
*
* @param longOutput Set to true if long output is requested, false if not.
* @param username The name of the user to finger.
* @return The result of the finger query.
* @throws IOException If an I/O error occurs while reading the socket.
*/
public String query(final boolean longOutput, final String username) throws IOException {
int read;
final StringBuilder result = new StringBuilder(buffer.length);
try (final BufferedReader input = new BufferedReader(new InputStreamReader(getInputStream(longOutput, username), getCharset()))) {
while (true) {
read = input.read(buffer, 0, buffer.length);
if (read <= 0) {
break;
}
result.append(buffer, 0, read);
}
}
return result.toString();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/finger/package-info.java 0000664 0000000 0000000 00000001553 14340477222 0032356 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Finger implementation
*/
package org.apache.commons.net.finger; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/ 0000775 0000000 0000000 00000000000 14340477222 0026502 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/Configurable.java 0000664 0000000 0000000 00000002441 14340477222 0031746 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
/**
* This interface adds the aspect of configurability by means of a supplied FTPClientConfig object to other classes in the system, especially listing parsers.
*/
public interface Configurable {
/**
* @param config the object containing the configuration data
* @throws IllegalArgumentException if the elements of the config are somehow inadequate to configure the Configurable object.
*/
void configure(FTPClientConfig config);
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/DurationUtils.java 0000664 0000000 0000000 00000003135 14340477222 0032155 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.time.Duration;
/** Temporary until Commons Lang 3.12.0. */
class DurationUtils {
/**
* Tests whether the given Duration is positive (>0).
*
* @param duration the value to test
* @return whether the given Duration is positive (>0).
*/
static boolean isPositive(final Duration duration) {
return duration != null && !duration.isNegative() && !duration.isZero();
}
static int toMillisInt(final Duration duration) {
final long millis = duration.toMillis();
return millis > 0 ? (int) Math.min(millis, Integer.MAX_VALUE) : (int) Math.max(millis, Integer.MIN_VALUE);
}
static Duration zeroIfNull(final Duration controlIdle) {
return controlIdle == null ? Duration.ZERO : controlIdle;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTP.java 0000664 0000000 0000000 00000235603 14340477222 0030007 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
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;
import org.apache.commons.net.util.NetConstants;
/**
* FTP provides the basic the functionality necessary to implement your own FTP client. It extends org.apache.commons.net.SocketClient since extending
* TelnetClient was causing unwanted behavior (like connections that did not time out properly).
* FTPConectionClosedException is a
* subclass of 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 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
* getReplyStrings}. You may avoid server disconnections while the client is idle by periodicaly sending NOOP commands to the server.
* FILE_TYPE are used to indicate file types.
*/
public static final int ASCII_FILE_TYPE = 0;
/**
* A constant used to indicate the file(s) being transferred should be treated as EBCDIC. Note however that there are several different EBCDIC formats. All
* constants ending in FILE_TYPE are used to indicate file types.
*/
public static final int EBCDIC_FILE_TYPE = 1;
/**
* A constant used to indicate the file(s) being transferred should be treated as a binary image, i.e., no translations should be performed. All constants
* ending in FILE_TYPE are used to indicate file types.
*/
public static final int BINARY_FILE_TYPE = 2;
/**
* A constant used to indicate the file(s) being transferred should be treated as a local type. All constants ending in FILE_TYPE are used to
* indicate file types.
*/
public static final int LOCAL_FILE_TYPE = 3;
/**
* A constant used for text files to indicate a non-print text format. This is the default format. All constants ending in TEXT_FORMAT are used
* to indicate text formatting for text transfers (both ASCII and EBCDIC).
*/
public static final int NON_PRINT_TEXT_FORMAT = 4;
/**
* A constant used to indicate a text file contains format vertical format control characters. All constants ending in TEXT_FORMAT are used to
* indicate text formatting for text transfers (both ASCII and EBCDIC).
*/
public static final int TELNET_TEXT_FORMAT = 5;
/**
* A constant used to indicate a text file contains ASA vertical format control characters. All constants ending in TEXT_FORMAT are used to
* indicate text formatting for text transfers (both ASCII and EBCDIC).
*/
public static final int CARRIAGE_CONTROL_TEXT_FORMAT = 6;
/**
* A constant used to indicate a file is to be treated as a continuous sequence of bytes. This is the default structure. All constants ending in
* _STRUCTURE are used to indicate file structure for file transfers.
*/
public static final int FILE_STRUCTURE = 7;
/**
* A constant used to indicate a file is to be treated as a sequence of records. All constants ending in _STRUCTURE are used to indicate file
* structure for file transfers.
*/
public static final int RECORD_STRUCTURE = 8;
/**
* A constant used to indicate a file is to be treated as a set of independent indexed pages. All constants ending in _STRUCTURE are used to
* indicate file structure for file transfers.
*/
public static final int PAGE_STRUCTURE = 9;
/**
* A constant used to indicate a file is to be transferred as a stream of bytes. This is the default transfer mode. All constants ending in
* TRANSFER_MODE are used to indicate file transfer modes.
*/
public static final int STREAM_TRANSFER_MODE = 10;
/**
* A constant used to indicate a file is to be transferred as a series of blocks. All constants ending in TRANSFER_MODE are used to indicate
* file transfer modes.
*/
public static final int BLOCK_TRANSFER_MODE = 11;
/**
* A constant used to indicate a file is to be transferred as FTP compressed data. All constants ending in TRANSFER_MODE are used to indicate
* file transfer modes.
*/
public static final int COMPRESSED_TRANSFER_MODE = 12;
// 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.
/**
* The default character encoding used for communicating over an FTP control connection. The default encoding is an ASCII-compatible encoding. Some FTP
* servers expect other encodings. You can change the encoding used by an FTP instance with {@link #setControlEncoding setControlEncoding}.
*/
public static final String DEFAULT_CONTROL_ENCODING = "ISO-8859-1";
/** Length of the FTP reply code (3 alphanumerics) */
public static final int REPLY_CODE_LEN = 3;
private static final String modes = "AEILNTCFRPSBC";
protected int _replyCode;
protected ArrayListDEFAULT_PORT and initializes internal data structures for saving FTP reply
* information.
*/
public FTP() {
setDefaultPort(DEFAULT_PORT);
_replyLines = new ArrayList<>();
_newReplyString = false;
_replyString = null;
_controlEncoding = DEFAULT_CONTROL_ENCODING;
_commandSupport_ = new ProtocolCommandSupport(this);
}
/**
* Get the reply, but don't pass it to command listeners. Used for keep-alive processing only.
*
* @since 3.0
* @throws IOException on error
*/
protected void __getReplyNoReport() throws IOException {
getReply(false);
}
/**
* Send a noop and get the reply without reporting to the command listener. Intended for use with keep-alive.
*
* @throws IOException on error
* @since 3.0
*/
protected void __noop() throws IOException {
final String msg = buildMessage(FTPCmd.NOOP.getCommand(), null);
send(msg);
__getReplyNoReport(); // This may timeout
}
/**
* Initiates control connections and gets initial reply. Initializes {@link #_controlInput_} and {@link #_controlOutput_}.
*/
@Override
protected void _connectAction_() throws IOException {
_connectAction_(null);
}
/**
* Initiates control connections and gets initial reply. Initializes {@link #_controlInput_} and {@link #_controlOutput_}.
*
* @param socketIsReader the reader to reuse (if non-null)
* @throws IOException on error
* @since 3.4
*/
protected void _connectAction_(final Reader socketIsReader) throws IOException {
super._connectAction_(); // sets up _input_ and _output_
if (socketIsReader == null) {
_controlInput_ = new CRLFLineReader(new InputStreamReader(_input_, getControlEncoding()));
} else {
_controlInput_ = new CRLFLineReader(socketIsReader);
}
_controlOutput_ = new BufferedWriter(new OutputStreamWriter(_output_, getControlEncoding()));
if (connectTimeout > 0) { // NET-385
final int original = _socket_.getSoTimeout();
_socket_.setSoTimeout(connectTimeout);
try {
getReply();
// If we received code 120, we have to fetch completion reply.
if (FTPReply.isPositivePreliminary(_replyCode)) {
getReply();
}
} catch (final SocketTimeoutException e) {
final IOException ioe = new IOException("Timed out waiting for initial connect reply");
ioe.initCause(e);
throw ioe;
} finally {
_socket_.setSoTimeout(original);
}
} else {
getReply();
// If we received code 120, we have to fetch completion reply.
if (FTPReply.isPositivePreliminary(_replyCode)) {
getReply();
}
}
}
/**
* A convenience method to send the FTP ABOR command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 abor() throws IOException {
return sendCommand(FTPCmd.ABOR);
}
/**
* A convenience method to send the FTP ACCT command to the server, receive the reply, and return the reply code.
*
* @param account The account name to access.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 acct(final String account) throws IOException {
return sendCommand(FTPCmd.ACCT, account);
}
/**
* A convenience method to send the FTP ALLO command to the server, receive the reply, and return the reply code.
*
* @param bytes The number of bytes to allocate.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 allo(final int bytes) throws IOException {
return sendCommand(FTPCmd.ALLO, Integer.toString(bytes));
}
/**
* A convenience method to send the FTP ALLO command to the server, receive the reply, and return the reply code.
*
* @param bytes The number of bytes to allocate.
* @param recordSize The size of a record.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 allo(final int bytes, final int recordSize) throws IOException {
return sendCommand(FTPCmd.ALLO, Integer.toString(bytes) + " R " + Integer.toString(recordSize));
}
/**
* A convenience method to send the FTP ALLO command to the server, receive the reply, and return the reply code.
*
* @param bytes The number of bytes to allocate.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 allo(final long bytes) throws IOException {
return sendCommand(FTPCmd.ALLO, Long.toString(bytes));
}
/**
* A convenience method to send the FTP ALLO command to the server, receive the reply, and return the reply code.
*
* @param bytes The number of bytes to allocate.
* @param recordSize The size of a record.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 allo(final long bytes, final int recordSize) throws IOException {
return sendCommand(FTPCmd.ALLO, Long.toString(bytes) + " R " + Integer.toString(recordSize));
}
/**
* A convenience method to send the FTP APPE command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param pathname The pathname to use for the file when stored at the remote end of the transfer.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 appe(final String pathname) throws IOException {
return sendCommand(FTPCmd.APPE, pathname);
}
private String buildMessage(final String command, final String args) {
final StringBuilder __commandBuffer = new StringBuilder();
__commandBuffer.append(command);
if (args != null) {
__commandBuffer.append(' ');
__commandBuffer.append(args);
}
__commandBuffer.append(SocketClient.NETASCII_EOL);
return __commandBuffer.toString();
}
/**
* A convenience method to send the FTP CDUP command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 cdup() throws IOException {
return sendCommand(FTPCmd.CDUP);
}
/**
* A convenience method to send the FTP CWD command to the server, receive the reply, and return the reply code.
*
* @param directory The new working directory.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 cwd(final String directory) throws IOException {
return sendCommand(FTPCmd.CWD, directory);
}
/**
* A convenience method to send the FTP DELE command to the server, receive the reply, and return the reply code.
*
* @param pathname The pathname to delete.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 dele(final String pathname) throws IOException {
return sendCommand(FTPCmd.DELE, pathname);
}
/**
* Closes the control connection to the FTP 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. Also sets {@link #_controlInput_} and
* {@link #_controlOutput_} to null.
*
* @throws IOException If an error occurs while disconnecting.
*/
@Override
public void disconnect() throws IOException {
super.disconnect();
_controlInput_ = null;
_controlOutput_ = null;
_newReplyString = false;
_replyString = null;
}
/**
* A convenience method to send the FTP EPRT command to the server, receive the reply, and return the reply code.
*
* Examples:
*
*
*
* @see "http://www.faqs.org/rfcs/rfc2428.html"
*
* @param host The host owning the port.
* @param port The new port.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 2.2
*/
public int eprt(final InetAddress host, final int port) throws IOException {
final int num;
final StringBuilder info = new StringBuilder();
String h;
// If IPv6, trim the zone index
h = host.getHostAddress();
num = h.indexOf('%');
if (num > 0) {
h = h.substring(0, num);
}
info.append("|");
if (host instanceof Inet4Address) {
info.append("1");
} else if (host instanceof Inet6Address) {
info.append("2");
}
info.append("|");
info.append(h);
info.append("|");
info.append(port);
info.append("|");
return sendCommand(FTPCmd.EPRT, info.toString());
}
/**
* A convenience method to send the FTP EPSV command to the server, receive the reply, and return the reply code. Remember, it's up to you to interpret the
* reply string containing the host/port information.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 2.2
*/
public int epsv() throws IOException {
return sendCommand(FTPCmd.EPSV);
}
/**
* A convenience method to send the FTP FEAT command to the server, receive the reply, and return the reply code.
*
* @return The reply code received by the server
* @throws IOException If an I/O error occurs while either sending the command or receiving the server reply.
* @since 2.2
*/
public int feat() throws IOException {
return sendCommand(FTPCmd.FEAT);
}
/**
* Provide command support to super-class
*/
@Override
protected ProtocolCommandSupport getCommandSupport() {
return _commandSupport_;
}
/**
* @return The character encoding used to communicate over the control connection.
*/
public String getControlEncoding() {
return _controlEncoding;
}
/**
* Fetches 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
* 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.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 {
return getReply(true);
}
private int getReply(final boolean reportReply) throws IOException {
final int length;
_newReplyString = true;
_replyLines.clear();
String line = _controlInput_.readLine();
if (line == null) {
throw new FTPConnectionClosedException("Connection closed without indication.");
}
// In case we run into an anomaly we don't want fatal index exceptions
// to be thrown.
length = line.length();
if (length < REPLY_CODE_LEN) {
throw new MalformedServerReplyException("Truncated server reply: " + line);
}
String code = null;
try {
code = line.substring(0, REPLY_CODE_LEN);
_replyCode = Integer.parseInt(code);
} catch (final NumberFormatException e) {
throw new MalformedServerReplyException("Could not parse response code.\nServer Reply: " + line);
}
_replyLines.add(line);
// Check the server reply type
if (length > REPLY_CODE_LEN) {
final char sep = line.charAt(REPLY_CODE_LEN);
// Get extra lines if message continues.
if (sep == '-') {
do {
line = _controlInput_.readLine();
if (line == null) {
throw new FTPConnectionClosedException("Connection closed without indication.");
}
_replyLines.add(line);
// The length() check handles problems that could arise from readLine()
// returning too soon after encountering a naked CR or some other
// anomaly.
} while (isStrictMultilineParsing() ? strictCheck(line, code) : lenientCheck(line));
} else if (isStrictReplyParsing()) {
if (length == REPLY_CODE_LEN + 1) { // expecting some text
throw new MalformedServerReplyException("Truncated server reply: '" + line + "'");
}
if (sep != ' ') {
throw new MalformedServerReplyException("Invalid server reply: '" + line + "'");
}
}
} else if (isStrictReplyParsing()) {
throw new MalformedServerReplyException("Truncated server reply: '" + line + "'");
}
if (reportReply) {
fireReplyReceived(_replyCode, getReplyString());
}
if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE) {
throw new FTPConnectionClosedException("FTP response 421 received. Server closed connection.");
}
return _replyCode;
}
/**
* Returns the integer value of the reply code of the last FTP reply. You will usually only use this method after you connect to the FTP server to check
* that the connection was successful since connect is of type void.
*
* @return The integer value of the reply code of the last FTP reply.
*/
public int getReplyCode() {
return _replyCode;
}
/**
* Returns the entire text of the last FTP server response exactly as it was received, including all end of line markers in NETASCII format.
*
* @return The entire text from the last FTP response as a String.
*/
public String getReplyString() {
final StringBuilder buffer;
if (!_newReplyString) {
return _replyString;
}
buffer = new StringBuilder(256);
for (final String line : _replyLines) {
buffer.append(line);
buffer.append(SocketClient.NETASCII_EOL);
}
_newReplyString = false;
return _replyString = buffer.toString();
}
/**
* Returns the nth line of text from the last FTP server response as a string. The end of line markers of each are stripped from the line.
*
* @param index The index of the line to return, 0-based.
*
* @return The lines of text from the last FTP response as an array.
*/
String getReplyString(final int index) {
return _replyLines.get(index);
}
/**
* Returns the lines of text from the last FTP server response as an array of strings, one entry per line. The end of line markers of each are stripped from
* each line.
*
* @return The lines of text from the last FTP response as an array.
*/
public String[] getReplyStrings() {
return _replyLines.toArray(NetConstants.EMPTY_STRING_ARRAY);
}
/**
* A convenience method to send the FTP HELP command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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(FTPCmd.HELP);
}
/**
* A convenience method to send the FTP HELP command to the server, receive the reply, and return the reply code.
*
* @param command The command name on which to request help.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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(final String command) throws IOException {
return sendCommand(FTPCmd.HELP, command);
}
/**
* Return whether strict multiline parsing is enabled, as per RFC 959, section 4.2.
*
* @return True if strict, false if lenient
* @since 2.0
*/
public boolean isStrictMultilineParsing() {
return strictMultilineParsing;
}
/**
* Return whether strict non-multiline parsing is enabled, as per RFC 959, section 4.2.
*
* If false, only the 3 digit code is required (as was the case for versions up to 3.5)
*
* @return True if strict (default), false if additional checks are not made
* @since 3.6
*/
public boolean isStrictReplyParsing() {
return strictReplyParsing;
}
// The strict check is too strong a condition because of non-conforming ftp
// servers like ftp.funet.fi which sent 226 as the last line of a
// 426 multi-line reply in response to ls /. We relax the condition to
// test that the line starts with a digit rather than starting with
// the code.
private boolean lenientCheck(final String line) {
return !(line.length() > REPLY_CODE_LEN && line.charAt(REPLY_CODE_LEN) != '-' && Character.isDigit(line.charAt(0)));
}
/**
* A convenience method to send the FTP LIST command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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(FTPCmd.LIST);
}
/**
* A convenience method to send the FTP LIST command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param pathname The pathname to list, may be {@code null} in which case the command is sent with no parameters
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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(final String pathname) throws IOException {
return sendCommand(FTPCmd.LIST, pathname);
}
/**
* Sends the MDTM command for the given file.
*
* @param file name of file
* @return the status
* @throws IOException on error
* @since 2.0
**/
public int mdtm(final String file) throws IOException {
return sendCommand(FTPCmd.MDTM, file);
}
/**
* A convenience method to send the FTP MFMT command to the server, receive the reply, and return the reply code.
*
* @param pathname The pathname for which mtime is to be changed
* @param timeval Timestamp in yyyyMMDDhhmmss format
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 2.2
* @see http://tools.ietf.org/html/draft-somers-ftp-mfxx-04
**/
public int mfmt(final String pathname, final String timeval) throws IOException {
return sendCommand(FTPCmd.MFMT, timeval + " " + pathname);
}
/**
* A convenience method to send the FTP MKD command to the server, receive the reply, and return the reply code.
*
* @param pathname The pathname of the new directory to create.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 mkd(final String pathname) throws IOException {
return sendCommand(FTPCmd.MKD, pathname);
}
/**
* A convenience method to send the FTP MLSD command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 3.0
*/
public int mlsd() throws IOException {
return sendCommand(FTPCmd.MLSD);
}
/**
* A convenience method to send the FTP MLSD command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param path the path to report on
* @return The reply code received from the server, may be {@code null} in which case the command is sent with no parameters
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 3.0
*/
public int mlsd(final String path) throws IOException {
return sendCommand(FTPCmd.MLSD, path);
}
/**
* A convenience method to send the FTP MLST command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 3.0
*/
public int mlst() throws IOException {
return sendCommand(FTPCmd.MLST);
}
/**
* A convenience method to send the FTP MLST command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param path the path to report on
* @return The reply code received from the server, may be {@code null} in which case the command is sent with no parameters
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 3.0
*/
public int mlst(final String path) throws IOException {
return sendCommand(FTPCmd.MLST, path);
}
/**
* A convenience method to send the FTP MODE command to the server, receive the reply, and return the reply code.
*
* @param mode The transfer mode to use (one of the TRANSFER_MODE constants).
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 mode(final int mode) throws IOException {
return sendCommand(FTPCmd.MODE, modes.substring(mode, mode + 1));
}
/**
* A convenience method to send the FTP NLST command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 nlst() throws IOException {
return sendCommand(FTPCmd.NLST);
}
/**
* A convenience method to send the FTP NLST command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param pathname The pathname to list, may be {@code null} in which case the command is sent with no parameters
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 nlst(final String pathname) throws IOException {
return sendCommand(FTPCmd.NLST, pathname);
}
/**
* A convenience method to send the FTP NOOP command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 noop() throws IOException {
return sendCommand(FTPCmd.NOOP);
}
/**
* A convenience method to send the FTP PASS command to the server, receive the reply, and return the reply code.
*
* @param password The plain text password of the username being logged into.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 pass(final String password) throws IOException {
return sendCommand(FTPCmd.PASS, password);
}
/**
* A convenience method to send the FTP PASV command to the server, receive the reply, and return the reply code. Remember, it's up to you to interpret the
* reply string containing the host/port information.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 pasv() throws IOException {
return sendCommand(FTPCmd.PASV);
}
/**
* A convenience method to send the FTP PORT command to the server, receive the reply, and return the reply code.
*
* @param host The host owning the port.
* @param port The new port.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 port(final InetAddress host, final int port) throws IOException {
int num;
final StringBuilder info = new StringBuilder(24);
info.append(host.getHostAddress().replace('.', ','));
num = port >>> 8;
info.append(',');
info.append(num);
info.append(',');
num = port & 0xff;
info.append(num);
return sendCommand(FTPCmd.PORT, info.toString());
}
/**
* A convenience method to send the FTP PWD command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 pwd() throws IOException {
return sendCommand(FTPCmd.PWD);
}
/**
* A convenience method to send the FTP QUIT command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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(FTPCmd.QUIT);
}
/**
* A convenience method to send the FTP REIN command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 rein() throws IOException {
return sendCommand(FTPCmd.REIN);
}
/**
* A convenience method to send the FTP REST command to the server, receive the reply, and return the reply code.
*
* @param marker The marker at which to restart a transfer.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 rest(final String marker) throws IOException {
return sendCommand(FTPCmd.REST, marker);
}
/**
* A convenience method to send the FTP RETR command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param pathname The pathname of the file to retrieve.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 retr(final String pathname) throws IOException {
return sendCommand(FTPCmd.RETR, pathname);
}
/**
* A convenience method to send the FTP RMD command to the server, receive the reply, and return the reply code.
*
* @param pathname The pathname of the directory to remove.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 rmd(final String pathname) throws IOException {
return sendCommand(FTPCmd.RMD, pathname);
}
/**
* A convenience method to send the FTP RNFR command to the server, receive the reply, and return the reply code.
*
* @param pathname The pathname to rename from.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 rnfr(final String pathname) throws IOException {
return sendCommand(FTPCmd.RNFR, pathname);
}
/**
* A convenience method to send the FTP RNTO command to the server, receive the reply, and return the reply code.
*
* @param pathname The pathname to rename to
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 rnto(final String pathname) throws IOException {
return sendCommand(FTPCmd.RNTO, pathname);
}
private void send(final String message) throws IOException, FTPConnectionClosedException, SocketException {
try {
_controlOutput_.write(message);
_controlOutput_.flush();
} catch (final SocketException e) {
if (!isConnected()) {
throw new FTPConnectionClosedException("Connection unexpectedly closed.");
}
throw e;
}
}
/**
* 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 }.
*
* @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.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 3.3
*/
public int sendCommand(final FTPCmd command) throws IOException {
return sendCommand(command, null);
}
/**
* 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 }.
*
* @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.
* @return The integer value of the FTP reply code returned by the server in response to the command.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 3.3
*/
public int sendCommand(final FTPCmd command, final String args) throws IOException {
return sendCommand(command.getCommand(), args);
}
/**
* 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 }.
*
* @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.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 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 }.
*
* @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.
* @return The integer value of the FTP reply code returned by the server in response to the command.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @deprecated (3.3) Use {@link #sendCommand(FTPCmd, String)} instead
*/
@Deprecated
public int sendCommand(final int command, final String args) throws IOException {
return sendCommand(FTPCommand.getCommand(command), args);
}
/**
* 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 }.
*
* @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.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 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 }.
*
* @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.
* @return The integer value of the FTP reply code returned by the server in response to the command.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 {
if (_controlOutput_ == null) {
throw new IOException("Connection is not open");
}
final String message = buildMessage(command, args);
send(message);
fireCommandSent(command, message);
return getReply();
}
/**
* Saves the character encoding to be used by the FTP control connection. Some FTP servers require that commands be issued in a non-ASCII encoding like
* UTF-8 so that file names with multi-byte character representations (e.g, Big 8) can be specified.
*
* If false, only the 3 digit code is required (as was the case for versions up to 3.5)
*
*
* @param strictReplyParsing the setting
* @since 3.6
*/
public void setStrictReplyParsing(final boolean strictReplyParsing) {
this.strictReplyParsing = strictReplyParsing;
}
/**
* A convenience method to send the FTP SITE command to the server, receive the reply, and return the reply code.
*
* @param parameters The site parameters to send.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 site(final String parameters) throws IOException {
return sendCommand(FTPCmd.SITE, parameters);
}
/**
* A convenience method to send the FTP SIZE command to the server, receive the reply, and return the reply code.
*
* @param parameters The site parameters to send.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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.
* @since 3.7
*/
public int size(final String parameters) throws IOException {
return sendCommand(FTPCmd.SIZE, parameters);
}
/**
* A convenience method to send the FTP SMNT command to the server, receive the reply, and return the reply code.
*
* @param dir The directory name.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 smnt(final String dir) throws IOException {
return sendCommand(FTPCmd.SMNT, dir);
}
/**
* A convenience method to send the FTP STAT command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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(FTPCmd.STAT);
}
/**
* A convenience method to send the FTP STAT command to the server, receive the reply, and return the reply code.
*
* @param pathname A pathname to list.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 pathname) throws IOException {
return sendCommand(FTPCmd.STAT, pathname);
}
/**
* A convenience method to send the FTP STOR command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param pathname The pathname to use for the file when stored at the remote end of the transfer.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 stor(final String pathname) throws IOException {
return sendCommand(FTPCmd.STOR, pathname);
}
/**
* A convenience method to send the FTP STOU command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 stou() throws IOException {
return sendCommand(FTPCmd.STOU);
}
/**
* A convenience method to send the FTP STOU command to the server, receive the reply, and return the reply code. Remember, it is up to you to manage the
* data connection. If you don't need this low level of access, use {@link org.apache.commons.net.ftp.FTPClient} , which will handle all low level details
* for you.
*
* @param pathname The base pathname to use for the file when stored at the remote end of the transfer. Some FTP servers require this.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 stou(final String pathname) throws IOException {
return sendCommand(FTPCmd.STOU, pathname);
}
// The RFC-compliant multiline termination check
private boolean strictCheck(final String line, final String code) {
return !(line.startsWith(code) && line.charAt(REPLY_CODE_LEN) == ' ');
}
/**
* A convenience method to send the FTP STRU command to the server, receive the reply, and return the reply code.
*
* @param structure The structure of the file (one of the _STRUCTURE constants).
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 stru(final int structure) throws IOException {
return sendCommand(FTPCmd.STRU, modes.substring(structure, structure + 1));
}
/**
* A convenience method to send the FTP SYST command to the server, receive the reply, and return the reply code.
*
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 syst() throws IOException {
return sendCommand(FTPCmd.SYST);
}
/**
* A convenience method to send the FTP TYPE command to the server, receive the reply, and return the reply code.
*
* @param fileType The type of the file (one of the FILE_TYPE constants).
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 type(final int fileType) throws IOException {
return sendCommand(FTPCmd.TYPE, modes.substring(fileType, fileType + 1));
}
/**
* A convenience method to send the FTP TYPE command for text files to the server, receive the reply, and return the reply code.
*
* @param fileType The type of the file (one of the FILE_TYPE constants).
* @param formatOrByteSize The format of the file (one of the _FORMAT constants. In the case of LOCAL_FILE_TYPE, the byte size.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 type(final int fileType, final int formatOrByteSize) throws IOException {
final StringBuilder arg = new StringBuilder();
arg.append(modes.charAt(fileType));
arg.append(' ');
if (fileType == LOCAL_FILE_TYPE) {
arg.append(formatOrByteSize);
} else {
arg.append(modes.charAt(formatOrByteSize));
}
return sendCommand(FTPCmd.TYPE, arg.toString());
}
/**
* A convenience method to send the FTP USER command to the server, receive the reply, and return the reply code.
*
* @param username The username to login under.
* @return The reply code received from the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. 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 user(final String username) throws IOException {
return sendCommand(FTPCmd.USER, username);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPClient.java 0000664 0000000 0000000 00000544276 14340477222 0031157 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Locale;
import java.util.Properties;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import org.apache.commons.net.MalformedServerReplyException;
import org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory;
import org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory;
import org.apache.commons.net.ftp.parser.MLSxEntryParser;
import org.apache.commons.net.io.CRLFLineReader;
import org.apache.commons.net.io.CopyStreamAdapter;
import org.apache.commons.net.io.CopyStreamEvent;
import org.apache.commons.net.io.CopyStreamListener;
import org.apache.commons.net.io.FromNetASCIIInputStream;
import org.apache.commons.net.io.SocketOutputStream;
import org.apache.commons.net.io.ToNetASCIIOutputStream;
import org.apache.commons.net.io.Util;
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
* 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:
*
*
* FTPClient ftp = new FTPClient();
* FTPClientConfig config = new FTPClientConfig();
* config.setXXX(YYY); // change required options
* // for example config.setServerTimeZoneId("Pacific/Pitcairn")
* ftp.configure(config );
* boolean error = false;
* try {
* int reply;
* String server = "ftp.example.com";
* ftp.connect(server);
* System.out.println("Connected to " + server + ".");
* System.out.print(ftp.getReplyString());
*
* // After connection attempt, you should check the reply code to verify
* // success.
* reply = ftp.getReplyCode();
*
* if(!FTPReply.isPositiveCompletion(reply)) {
* ftp.disconnect();
* System.err.println("FTP server refused connection.");
* System.exit(1);
* }
* ... // transfer files
* ftp.logout();
* } catch(IOException e) {
* error = true;
* e.printStackTrace();
* } finally {
* if(ftp.isConnected()) {
* try {
* ftp.disconnect();
* } catch(IOException ioe) {
* // do nothing
* }
* }
* System.exit(error ? 1 : 0);
* }
*
* FTP.ASCII_FILE_TYPE , FTP.NON_PRINT_TEXT_FORMAT ,
* FTP.STREAM_TRANSFER_MODE , and FTP.FILE_STRUCTURE . The only file types directly supported are FTP.ASCII_FILE_TYPE
* and FTP.BINARY_FILE_TYPE . Because there are at least 4 different EBCDIC encodings, we have opted not to provide direct support for EBCDIC. To
* transfer EBCDIC and other unsupported file types you must create your own filter InputStreams and OutputStreams and wrap them around the streams returned or
* required by the FTPClient methods. FTPClient uses the {@link ToNetASCIIOutputStream NetASCII} filter streams to provide transparent handling of ASCII files.
* We will consider incorporating EBCDIC support if there is enough demand.
* FTP.NON_PRINT_TEXT_FORMAT , FTP.STREAM_TRANSFER_MODE , and FTP.FILE_STRUCTURE are the only supported formats,
* transfer modes, and file structures.
* FTPConnectionClosedException is a
* subclass of 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 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 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.
*
* FTPClient f = new FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = f.listFiles(directory);
*
*
* FTPClient f = new FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPListParseEngine engine = f.initiateListParsing("com.whatever.YourOwnParser", directory);
*
* while (engine.hasNext()) {
* FTPFile[] files = engine.getNext(25); // "page size" you want
* // do whatever you want with these files, display them, etc.
* // expensive FTPFile objects not created until needed.
* }
*
*
* FTPClient f = new FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPListParseEngine engine = f.initiateListParsing(directory);
*
* while (engine.hasNext()) {
* FTPFile[] files = engine.getNext(25); // "page size" you want
* // do whatever you want with these files, display them, etc.
* // expensive FTPFile objects not created until needed.
* }
*
*
*
* see {@link FTPClientConfig FTPClientConfig}.
* MM d yyyy
* One solution to this is to send a safe command (i.e. NOOP) over the control connection to reset the router's idle timer. This is enabled as follows:
*
*
* // Set timeout to 5 minutes
* ftpClient.setControlKeepAliveTimeout(Duration.ofMinutes(5));
*
*
* This will cause the file upload/download methods to send a NOOP approximately every 5 minutes. The following public methods support this:
*
*
* This feature does not apply to the methods where the user is responsible for writing or reading the data stream, i.e. {@link #retrieveFileStream(String)} ,
* {@link #storeFileStream(String)} and the other xxxFileStream methods. In such cases, the user is responsible for keeping the control connection alive if
* necessary.
*
* If defined, the value will be used to create any automatically created parsers.
*
* @since 3.0
*/
public static final String FTP_SYSTEM_TYPE = "org.apache.commons.net.ftp.systemType";
/**
* The system property ({@value}) which can be used as the default system type.
* If defined, the value will be used if the SYST command fails.
*
* @since 3.1
*/
public static final String FTP_SYSTEM_TYPE_DEFAULT = "org.apache.commons.net.ftp.systemType.default";
/**
* The system property that defines the default for {@link #isIpAddressFromPasvResponse()}. This property, if present, configures the default for the
* following: If the client receives the servers response for a PASV request, then that response will contain an IP address. If this property is true, then
* the client will use that IP address, as requested by the server. This is compatible to version {@code 3.8.0}, and before. If this property is false, or
* absent, then the client will ignore that IP address, and instead use the remote address of the control connection.
*
* @see #isIpAddressFromPasvResponse()
* @see #setIpAddressFromPasvResponse(boolean)
* @since 3.9.0
*/
public static final String FTP_IP_ADDRESS_FROM_PASV_RESPONSE = "org.apache.commons.net.ftp.ipAddressFromPasvResponse";
/**
* The name of an optional systemType properties file ({@value}), which is loaded using {@link Class#getResourceAsStream(String)}.
* The entries are the systemType (as determined by {@link FTPClient#getSystemType}) and the values are the replacement type or parserClass, which is passed
* to {@link FTPFileEntryParserFactory#createFileEntryParser(String)}.
* For example:
*
*
* Plan 9=Unix
* OS410=org.apache.commons.net.ftp.parser.OS400FTPEntryParser
*
*
* @since 3.0
*/
public static final String SYSTEM_TYPE_PROPERTIES = "/systemType.properties";
/**
* A constant indicating the FTP session is expecting all transfers to occur between the client (local) and server and that the server should connect to the
* client's data port to initiate a data transfer. This is the default data connection mode when and FTPClient instance is created.
*/
public static final int ACTIVE_LOCAL_DATA_CONNECTION_MODE = 0;
/**
* A constant indicating the FTP session is expecting all transfers to occur between two remote servers and that the server the client is connected to
* should connect to the other server's data port to initiate a data transfer.
*/
public static final int ACTIVE_REMOTE_DATA_CONNECTION_MODE = 1;
/**
* A constant indicating the FTP session is expecting all transfers to occur between the client (local) and server and that the server is in passive mode,
* requiring the client to connect to the server's data port to initiate a transfer.
*/
public static final int PASSIVE_LOCAL_DATA_CONNECTION_MODE = 2;
/**
* A constant indicating the FTP session is expecting all transfers to occur between two remote servers and that the server the client is connected to is in
* passive mode, requiring the other server to connect to the first server's data port to initiate a data transfer.
*/
public static final int PASSIVE_REMOTE_DATA_CONNECTION_MODE = 3;
/** Pattern for PASV mode responses. Groups: (n,n,n,n),(n),(n) */
private static final java.util.regex.Pattern PARMS_PAT;
static {
PARMS_PAT = java.util.regex.Pattern.compile("(\\d{1,3},\\d{1,3},\\d{1,3},\\d{1,3}),(\\d{1,3}),(\\d{1,3})");
}
private static Properties getOverrideProperties() {
return PropertiesSingleton.PROPERTIES;
}
/**
* Parse the pathname from a CWD reply.
* ACTIVE_LOCAL_DATA_CONNECTION_MODE ,
* the file type set to FTP.ASCII_FILE_TYPE , the file format set to FTP.NON_PRINT_TEXT_FORMAT , the file structure set to
* FTP.FILE_STRUCTURE , and the transfer mode set to FTP.STREAM_TRANSFER_MODE .
*
* FTPClient ftp = new FTPClient();
* FTPClientConfig config = new FTPClientConfig();
* config.setLenientFutureDates(true);
* ftp.configure(config);
*
*/
public FTPClient() {
initDefaults();
dataTimeout = Duration.ofMillis(-1);
remoteVerificationEnabled = true;
parserFactory = new DefaultFTPFileEntryParserFactory();
configuration = null;
listHiddenFiles = false;
useEPSVwithIPv4 = false;
random = new Random();
passiveLocalHost = null;
}
@Override
protected void _connectAction_() throws IOException {
_connectAction_(null);
}
/**
* @param socketIsReader the reader to reuse (if non-null)
* @throws IOException on error
* @since 3.4
*/
@Override
protected void _connectAction_(final Reader socketIsReader) throws IOException {
super._connectAction_(socketIsReader); // sets up _input_ and _output_
initDefaults();
// must be after super._connectAction_(), because otherwise we get an
// Exception claiming we're not connected
if (autodetectEncoding) {
final ArrayList
* InputStream input;
* OutputStream output;
* input = new FileInputStream("foobaz.txt");
* output = ftp.storeFileStream("foobar.txt")
* if(!FTPReply.isPositiveIntermediate(ftp.getReplyCode())) {
* input.close();
* output.close();
* ftp.logout();
* ftp.disconnect();
* System.err.println("File transfer failed.");
* System.exit(1);
* }
* Util.copyStream(input, output);
* input.close();
* output.close();
* // Must call completePendingCommand() to finish command.
* if(!ftp.completePendingCommand()) {
* ftp.logout();
* ftp.disconnect();
* System.err.println("File transfer failed.");
* System.exit(1);
* }
*
*
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean completePendingCommand() throws IOException {
return FTPReply.isPositiveCompletion(getReply());
}
/**
* Implementation of the {@link Configurable Configurable} interface. In the case of this class, configuring merely makes the config object available for
* the factory methods that construct parsers.
*
* @param config {@link FTPClientConfig FTPClientConfig} object used to provide non-standard configurations to the parser.
* @since 1.4
*/
@Override
public void configure(final FTPClientConfig config) {
this.configuration = config;
}
// package access for test purposes
void createParser(final String parserKey) throws IOException {
// We cache the value to avoid creation of a new object every
// time a file listing is generated.
// Note: we don't check against a null parserKey (NET-544)
if (entryParser == null || (parserKey != null && !entryParserKey.equals(parserKey))) {
if (null != parserKey) {
// if a parser key was supplied in the parameters,
// use that to create the parser
entryParser = parserFactory.createFileEntryParser(parserKey);
entryParserKey = parserKey;
} else // if no parserKey was supplied, check for a configuration
// in the params, and if it has a non-empty system type, use that.
if (null != configuration && configuration.getServerSystemKey().length() > 0) {
entryParser = parserFactory.createFileEntryParser(configuration);
entryParserKey = configuration.getServerSystemKey();
} else {
// if a parserKey hasn't been supplied, and a configuration
// hasn't been supplied, and the override property is not set
// then autodetect by calling
// the SYST command and use that to choose the parser.
String systemType = System.getProperty(FTP_SYSTEM_TYPE);
if (systemType == null) {
systemType = getSystemType(); // cannot be null
final Properties override = getOverrideProperties();
if (override != null) {
final String newType = override.getProperty(systemType);
if (newType != null) {
systemType = newType;
}
}
}
if (null != configuration) { // system type must have been empty above
entryParser = parserFactory.createFileEntryParser(new FTPClientConfig(systemType, configuration));
} else {
entryParser = parserFactory.createFileEntryParser(systemType);
}
entryParserKey = systemType;
}
}
}
/**
* Deletes a file on the FTP server.
*
* @param pathname The pathname of the file to be deleted.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean deleteFile(final String pathname) throws IOException {
return FTPReply.isPositiveCompletion(dele(pathname));
}
/**
* Closes the connection to the FTP server and restores connection parameters to the default values.
*
* @throws IOException If an error occurs while disconnecting.
*/
@Override
public void disconnect() throws IOException {
super.disconnect();
initDefaults();
}
/**
* Issue a command and wait for the reply.
* ACTIVE_LOCAL_DATA_CONNECTION_MODE. No communication with the FTP server is conducted, but this
* causes all future data transfers to require the FTP server to connect to the client's data port. Additionally, to accommodate differences between socket
* implementations on different platforms, this method causes the client to issue a PORT command before every data transfer.
*/
public void enterLocalActiveMode() {
dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE;
passiveHost = null;
passivePort = -1;
}
/**
* Set the current data connection mode to PASSIVE_LOCAL_DATA_CONNECTION_MODE . Use this method only for data transfers between the client and
* server. This method causes a PASV (or EPSV) command to be issued to the server before the opening of every data connection, telling the server to open a
* data port to which the client will connect to conduct data transfers. The FTPClient will stay in PASSIVE_LOCAL_DATA_CONNECTION_MODE until
* the mode is changed by calling some other method such as {@link #enterLocalActiveMode enterLocalActiveMode() }
* ACTIVE_REMOTE_DATA_CONNECTION . Use this method only for server to server data transfers. This
* method issues a PORT command to the server, indicating the other server and port to which it should connect for data transfers. You must call this method
* before EVERY server to server transfer attempt. The FTPClient will NOT automatically continue to issue PORT commands. You also must remember to call
* {@link #enterLocalActiveMode enterLocalActiveMode() } if you wish to return to the normal data connection mode.
*
* @param host The passive mode server accepting connections for data transfers.
* @param port The passive mode server's data port.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean enterRemoteActiveMode(final InetAddress host, final int port) throws IOException {
if (FTPReply.isPositiveCompletion(port(host, port))) {
dataConnectionMode = ACTIVE_REMOTE_DATA_CONNECTION_MODE;
passiveHost = null;
passivePort = -1;
return true;
}
return false;
}
/**
* Set the current data connection mode to PASSIVE_REMOTE_DATA_CONNECTION_MODE . Use this method only for server to server data transfers.
* This method issues a PASV command to the server, telling it to open a data port to which the active server will connect to conduct data transfers. You
* must call this method before EVERY server to server transfer attempt. The FTPClient will NOT automatically continue to issue PASV commands. You also must
* remember to call {@link #enterLocalActiveMode enterLocalActiveMode() } if you wish to return to the normal data connection mode.
*
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean enterRemotePassiveMode() throws IOException {
if (pasv() != FTPReply.ENTERING_PASSIVE_MODE) {
return false;
}
dataConnectionMode = PASSIVE_REMOTE_DATA_CONNECTION_MODE;
_parsePassiveModeReply(_replyLines.get(0));
return true;
}
/**
* Queries the server for supported features. The server may reply with a list of server-supported extensions. For example, a typical client-server
* interaction might be (from RFC 2389):
*
*
C> feat
S> 211-Extensions supported:
S> MLST size*;create;modify*;perm;media-type
S> SIZE
S> COMPRESSION
S> MDTM
S> 211 END
*
*
* @see http://www.faqs.org/rfcs/rfc2389.html
* @return True if successfully completed, false if not.
* @throws IOException on error
* @since 2.2
*/
public boolean features() throws IOException {
return FTPReply.isPositiveCompletion(feat());
}
/**
* Queries the server for a supported feature, and returns the its value (if any). Caches the parsed response to avoid resending the command repeatedly.
*
* @param feature the feature to check
*
* @return if the feature is present, returns the feature value or the empty string if the feature exists but has no value. Returns {@code null} if the
* feature is not found or the command failed. Check {@link #getReplyCode()} or {@link #getReplyString()} if so.
* @throws IOException on error
* @since 3.0
*/
public String featureValue(final String feature) throws IOException {
final String[] values = featureValues(feature);
if (values != null) {
return values[0];
}
return null;
}
/**
* Queries the server for a supported feature, and returns its values (if any). Caches the parsed response to avoid resending the command repeatedly.
*
* @param feature the feature to check
*
* @return if the feature is present, returns the feature values (empty array if none) Returns {@code null} if the feature is not found or the command
* failed. Check {@link #getReplyCode()} or {@link #getReplyString()} if so.
* @throws IOException on error
* @since 3.0
*/
public String[] featureValues(final String feature) throws IOException {
if (!initFeatureMap()) {
return null;
}
final Set
*
*
* @deprecated 3.7 For testing only; may be dropped or changed at any time
* @return the debug array
*/
@Deprecated // only for use in testing
public int[] getCslDebug() {
return cslDebug;
}
/**
* Returns the current data connection mode (one of the _DATA_CONNECTION_MODE constants.
*
* @return The current data connection mode (one of the _DATA_CONNECTION_MODE constants.
*/
public int getDataConnectionMode() {
return dataConnectionMode;
}
/**
* Gets the timeout to use when reading from the data connection. This timeout will be set immediately after opening the data connection, provided that the
* value is ≥ 0.
* yyyyMMDDhhmmss format.
* @throws IOException if an I/O error occurs.
* @since 2.0
*/
public String getModificationTime(final String pathname) throws IOException {
if (FTPReply.isPositiveCompletion(mdtm(pathname))) {
// skip the return code (e.g. 213) and the space
return getReplyString(0).substring(4);
}
return null;
}
/**
* Returns the hostname or IP address (in the form of a string) returned by the server when entering passive mode. If not in passive mode, returns null.
* This method only returns a valid value AFTER a data connection has been opened after a call to {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
* This is because FTPClient sends a PASV command to the server only just before opening a data connection, and not when you call
* {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
*
* @return The passive host name if in passive mode, otherwise null.
*/
public String getPassiveHost() {
return passiveHost;
}
/**
* Set the local IP address in passive mode. Useful when there are multiple network cards.
*
* @return The local IP address in passive mode.
*/
public InetAddress getPassiveLocalIPAddress() {
return this.passiveLocalHost;
}
/**
* If in passive mode, returns the data port of the passive host. This method only returns a valid value AFTER a data connection has been opened after a
* call to {@link #enterLocalPassiveMode enterLocalPassiveMode()}. This is because FTPClient sends a PASV command to the server only just before opening a
* data connection, and not when you call {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
*
* @return The data port of the passive server. If not in passive mode, undefined.
*/
public int getPassivePort() {
return passivePort;
}
/**
* Retrieve the value to be used for the data socket SO_RCVBUF option.
*
* @return The current buffer size.
* @since 3.3
*/
public int getReceiveDataSocketBufferSize() {
return receiveDataSocketBufferSize;
}
/**
* Get the reported host address for active mode EPRT/PORT commands; allows override of {@link #getHostAddress()}.
*
* Useful for FTP Client behind Firewall NAT.
*
* @return __reportActiveExternalHost if non-null, else getHostAddress();
*/
InetAddress getReportHostAddress() {
if (reportActiveExternalHost != null) {
return reportActiveExternalHost;
}
return getHostAddress();
}
/**
* Fetches the restart offset.
*
* @return offset The offset into the remote file at which to start the next file transfer.
*/
public long getRestartOffset() {
return restartOffset;
}
/**
* Retrieve the value to be used for the data socket SO_SNDBUF option.
*
* @return The current buffer size.
* @since 3.3
*/
public int getSendDataSocketBufferSize() {
return sendDataSocketBufferSize;
}
/**
* Issue the FTP SIZE command to the server for a given pathname. This should produce the size of the file.
*
* @param pathname the file name
*
* @return The size information returned by the server; {@code null} if there was an error
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @since 3.7
*/
public String getSize(final String pathname) throws IOException {
if (FTPReply.isPositiveCompletion(size(pathname))) {
return getReplyString(0).substring(4); // skip the return code (e.g. 213) and the space
}
return null;
}
/**
* Issue the FTP STAT command to the server.
*
* @return The status information returned by the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String getStatus() throws IOException {
if (FTPReply.isPositiveCompletion(stat())) {
return getReplyString();
}
return null;
}
/**
* Issue the FTP STAT command to the server for a given pathname. This should produce a listing of the file or directory.
*
* @param pathname the file name
*
* @return The status information returned by the server.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String getStatus(final String pathname) throws IOException {
if (FTPReply.isPositiveCompletion(stat(pathname))) {
return getReplyString();
}
return null;
}
/**
* @deprecated use {@link #getSystemType()} instead
* @return the name
* @throws IOException on error
*/
@Deprecated
public String getSystemName() throws IOException {
if (systemName == null && FTPReply.isPositiveCompletion(syst())) {
systemName = _replyLines.get(_replyLines.size() - 1).substring(4);
}
return systemName;
}
/**
* Fetches the system type from the server and returns the string. This value is cached for the duration of the connection after the first call to this
* method. In other words, only the first time that you invoke this method will it issue a SYST command to the FTP server. FTPClient will remember the value
* and return the cached value until a call to disconnect.
* FTPFileEntryParser used.
* parser parameter. Null will be returned if a data
* connection cannot be opened. If the current working directory contains no files, an empty array will be the return.
*
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client
* being idle or some other reason causing the server to send FTP reply code 421.
* This exception may be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving
* a reply from the server.
* @throws org.apache.commons.net.ftp.parser.ParserInitializationException Thrown if the autodetect mechanism cannot resolve the type of system we are
* connected with.
* @see FTPListParseEngine
*/
public FTPListParseEngine initiateListParsing() throws IOException {
return initiateListParsing((String) null);
}
/**
* private method through which all listFiles() and initiateListParsing methods pass once a parser is determined.
*
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @see FTPListParseEngine
*/
private FTPListParseEngine initiateListParsing(final FTPFileEntryParser parser, final String pathname) throws IOException {
final Socket socket = _openDataConnection_(FTPCmd.LIST, getListArguments(pathname));
final FTPListParseEngine engine = new FTPListParseEngine(parser, configuration);
if (socket == null) {
return engine;
}
try {
engine.readServerList(socket.getInputStream(), getControlEncoding());
} finally {
Util.closeQuietly(socket);
}
completePendingCommand();
return engine;
}
/**
* Using the default autodetect mechanism, initialize an FTPListParseEngine object containing a raw file information for the supplied directory. This
* information is obtained through the LIST command. This object is then capable of being iterated to return a sequence of FTPFile objects with information
* filled in by the FTPFileEntryParser used.
*
* FTPClient f = FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPListParseEngine engine = f.initiateListParsing(directory);
*
* while (engine.hasNext()) {
* FTPFile[] files = engine.getNext(25); // "page size" you want
* // do whatever you want with these files, display them, etc.
* // expensive FTPFile objects not created until needed.
* }
*
*
* @param pathname the starting directory
*
* @return A FTPListParseEngine object that holds the raw information and is capable of providing parsed FTPFile objects, one for each file containing
* information contained in the given path in the format determined by the parser parameter. Null will be returned if a data
* connection cannot be opened. If the current working directory contains no files, an empty array will be the return.
*
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client
* being idle or some other reason causing the server to send FTP reply code 421.
* This exception may be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving
* a reply from the server.
* @throws org.apache.commons.net.ftp.parser.ParserInitializationException Thrown if the autodetect mechanism cannot resolve the type of system we are
* connected with.
* @see FTPListParseEngine
*/
public FTPListParseEngine initiateListParsing(final String pathname) throws IOException {
return initiateListParsing((String) null, pathname);
}
/**
* Using the supplied parser key, initialize an FTPListParseEngine object containing a raw file information for the supplied directory. This information is
* obtained through the LIST command. This object is then capable of being iterated to return a sequence of FTPFile objects with information filled in by
* the FTPFileEntryParser used.
* FTPFileEntryParser that should be used to
* parse each server file listing. May be {@code null}, in which case the code checks first the system property {@link #FTP_SYSTEM_TYPE},
* and if that is not defined the SYST command is used to provide the value. To allow for arbitrary system types, the return from the SYST
* command is used to look up an alias for the type in the {@link #SYSTEM_TYPE_PROPERTIES} properties file if it is available.
* @param pathname the starting directory
*
* @return A FTPListParseEngine object that holds the raw information and is capable of providing parsed FTPFile objects, one for each file containing
* information contained in the given path in the format determined by the parser parameter. Null will be returned if a data
* connection cannot be opened. If the current working directory contains no files, an empty array will be the return.
*
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client
* being idle or some other reason causing the server to send FTP reply code 421.
* This exception may be caught either as an IOException or independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving
* a reply from the server.
* @throws org.apache.commons.net.ftp.parser.ParserInitializationException Thrown if the parserKey parameter cannot be resolved by the selected parser
* factory. In the DefaultFTPEntryParserFactory, this will happen when parserKey is
* neither the fully qualified class name of a class implementing the interface
* org.apache.commons.net.ftp.FTPFileEntryParser nor a string containing one of the
* recognized keys mapping to such a parser or if class loader security issues
* prevent its being loaded.
* @see FTPListParseEngine
*/
public FTPListParseEngine initiateListParsing(final String parserKey, final String pathname) throws IOException {
createParser(parserKey); // create and cache parser
return initiateListParsing(entryParser, pathname);
}
/**
* Initiate list parsing for MLSD listings in the current working directory.
*
* @return the engine
* @throws IOException on error
*/
public FTPListParseEngine initiateMListParsing() throws IOException {
return initiateMListParsing(null);
}
/**
* Initiate list parsing for MLSD listings.
*
* @param pathname the path from where to MLSD.
* @return the engine.
* @throws IOException on error
*/
public FTPListParseEngine initiateMListParsing(final String pathname) throws IOException {
final Socket socket = _openDataConnection_(FTPCmd.MLSD, pathname);
final FTPListParseEngine engine = new FTPListParseEngine(MLSxEntryParser.getInstance(), configuration);
if (socket == null) {
return engine;
}
try {
engine.readServerList(socket.getInputStream(), getControlEncoding());
} finally {
Util.closeQuietly(socket);
completePendingCommand();
}
return engine;
}
/**
* Returns, whether the IP address from the server's response should be used. Until 3.9.0, this has always been the case. Beginning with 3.9.0, that IP
* address will be silently ignored, and replaced with the remote IP address of the control connection, unless this configuration option is given, which
* restores the old behavior. To enable this by default, use the system property {@link FTPClient#FTP_IP_ADDRESS_FROM_PASV_RESPONSE}.
*
* @return True, if the IP address from the server's response will be used (pre-3.9 compatible behavior), or false (ignore that IP address).
*
* @see FTPClient#FTP_IP_ADDRESS_FROM_PASV_RESPONSE
* @see #setIpAddressFromPasvResponse(boolean)
* @since 3.9.0
*/
public boolean isIpAddressFromPasvResponse() {
return ipAddressFromPasvResponse;
}
/**
* Return whether or not verification of the remote host participating in data connections is enabled. The default behavior is for verification to be
* enabled.
*
* @return True if verification is enabled, false if not.
*/
public boolean isRemoteVerificationEnabled() {
return remoteVerificationEnabled;
}
/**
* Whether should attempt to use EPSV with IPv4. Default (if not set) is false
*
* @return true if should attempt EPSV
* @since 2.2
*/
public boolean isUseEPSVwithIPv4() {
return useEPSVwithIPv4;
}
/**
* Using the default system autodetect mechanism, obtain a list of directories contained in the current working directory.
* FTPFileEntryParser used.
* FTPFileEntryParser used.
* FTPFileEntryParser used.
* FTPFileEntryParser used.
* listFiles("site", FTPFileFilters.DIRECTORY);
*
* @param pathname the initial path, may be null
* @param filter the filter, non-null
* @return the list of FTPFile entries.
* @throws IOException on error
* @since 2.2
*/
public FTPFile[] listFiles(final String pathname, final FTPFileFilter filter) throws IOException {
return initiateListParsing((String) null, pathname).getFiles(filter);
}
/**
* Fetches the system help information from the server and returns the full string.
*
* @return The system help string obtained from the server. null if the information could not be obtained.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String listHelp() throws IOException {
return FTPReply.isPositiveCompletion(help()) ? getReplyString() : null;
}
/**
* Fetches the help information for a given command from the server and returns the full string.
*
* @param command The command on which to ask for help.
* @return The command help string obtained from the server. null if the information could not be obtained.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String listHelp(final String command) throws IOException {
return FTPReply.isPositiveCompletion(help(command)) ? getReplyString() : null;
}
/**
* Obtain a list of file names in the current working directory This information is obtained through the NLST command. If the current directory contains no
* files, a zero length array is returned only if the FTP server returned a positive completion code, otherwise, null is returned (the FTP server returned a
* 550 error No files found.). If the directory is not empty, an array of file names in the directory is returned.
*
* @return The list of file names contained in the current working directory. null if the list could not be obtained. If there are no file names in the
* directory, a zero-length array is returned.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String[] listNames() throws IOException {
return listNames(null);
}
/**
* Obtain a list of file names in a directory (or just the name of a given file, which is not particularly useful). This information is obtained through the
* NLST command. If the given pathname is a directory and contains no files, a zero length array is returned only if the FTP server returned a positive
* completion code, otherwise null is returned (the FTP server returned a 550 error No files found.). If the directory is not empty, an array of file names
* in the directory is returned. If the pathname corresponds to a file, only that file will be listed. The server may or may not expand glob expressions.
*
* @param pathname The file or directory to list. Warning: the server may treat a leading '-' as an option introducer. If so, try using an absolute path, or
* prefix the path with ./ (unix style servers). Some servers may support "--" as meaning end of options, in which case "-- -xyz" should
* work.
* @return The list of file names contained in the given path. null if the list could not be obtained. If there are no file names in the directory, a
* zero-length array is returned.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public String[] listNames(final String pathname) throws IOException {
final ArrayList remoteRetrieve issued to it by another FTPClient.
*
* @param fileName The name of the file to be appended to, or if the file does not exist, the name to call the file being stored.
*
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean remoteAppend(final String fileName) throws IOException {
if (dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) {
return FTPReply.isPositivePreliminary(appe(fileName));
}
return false;
}
/**
* Initiate a server to server file transfer. This method tells the server to which the client is connected to retrieve a given file from the other server.
*
* @param fileName The name of the file to retrieve.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean remoteRetrieve(final String fileName) throws IOException {
if (dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) {
return FTPReply.isPositivePreliminary(retr(fileName));
}
return false;
}
/**
* Initiate a server to server file transfer. This method tells the server to which the client is connected to store a file on the other server using the
* given file name. The other server must have had a remoteRetrieve issued to it by another FTPClient.
*
* @param fileName The name to call the file that is to be stored.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean remoteStore(final String fileName) throws IOException {
if (dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) {
return FTPReply.isPositivePreliminary(stor(fileName));
}
return false;
}
/**
* Initiate a server to server file transfer. This method tells the server to which the client is connected to store a file on the other server using a
* unique file name. The other server must have had a remoteRetrieve issued to it by another FTPClient. Many FTP servers require that a base
* file name be given from which the unique file name can be derived. For those servers use the other version of remoteStoreUnique
*
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean remoteStoreUnique() throws IOException {
if (dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) {
return FTPReply.isPositivePreliminary(stou());
}
return false;
}
/**
* Initiate a server to server file transfer. This method tells the server to which the client is connected to store a file on the other server using a
* unique file name based on the given file name. The other server must have had a remoteRetrieve issued to it by another FTPClient.
*
* @param fileName The name on which to base the file name of the file that is to be stored.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean remoteStoreUnique(final String fileName) throws IOException {
if (dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE || dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE) {
return FTPReply.isPositivePreliminary(stou(fileName));
}
return false;
}
/**
* Removes a directory on the FTP server (if empty).
*
* @param pathname The pathname of the directory to remove.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean removeDirectory(final String pathname) throws IOException {
return FTPReply.isPositiveCompletion(rmd(pathname));
}
/**
* Renames a remote file.
*
* @param from The name of the remote file to rename.
* @param to The new name of the remote file.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean rename(final String from, final String to) throws IOException {
if (!FTPReply.isPositiveIntermediate(rnfr(from))) {
return false;
}
return FTPReply.isPositiveCompletion(rnto(to));
}
/**
* Restart a STREAM_TRANSFER_MODE file transfer starting from the given offset. This will only work on FTP servers supporting the REST comand
* for the stream transfer mode. However, most FTP servers support this. Any subsequent file transfer will start reading or writing the remote file from the
* indicated offset.
*
* @param offset The offset into the remote file at which to start the next file transfer.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @since 3.1 (changed from private to protected)
*/
protected boolean restart(final long offset) throws IOException {
restartOffset = 0;
return FTPReply.isPositiveIntermediate(rest(Long.toString(offset)));
}
/**
* Retrieves a named file from the server and writes it to the given OutputStream. This method does NOT close the given OutputStream. If the current file
* type is ASCII, line separators in the file are converted to the local representation.
* FTP.FILE_STRUCTURE if this method is never called or if a connect method is called.
*
* @param structure The structure of the file (one of the FTP class _STRUCTURE constants).
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean setFileStructure(final int structure) throws IOException {
if (FTPReply.isPositiveCompletion(stru(structure))) {
fileStructure = structure;
return true;
}
return false;
}
/**
* Sets the transfer mode. The default transfer mode FTP.STREAM_TRANSFER_MODE if this method is never called or if a connect method is
* called.
*
* @param mode The new transfer mode to use (one of the FTP class _TRANSFER_MODE constants).
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean setFileTransferMode(final int mode) throws IOException {
if (FTPReply.isPositiveCompletion(mode(mode))) {
fileTransferMode = mode;
return true;
}
return false;
}
/**
* Sets the file type to be transferred. This should be one of FTP.ASCII_FILE_TYPE , FTP.BINARY_FILE_TYPE, etc. The file type
* only needs to be set when you want to change the type. After changing it, the new type stays in effect until you change it again. The default file type
* is FTP.ASCII_FILE_TYPE if this method is never called.
* The server default is supposed to be ASCII (see RFC 959), however many ftp servers default to BINARY. To ensure correct operation with all servers,
* always specify the appropriate file type after connecting to the server.
* _FILE_TYPE constant indicating the type of file.
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean setFileType(final int fileType) throws IOException {
if (FTPReply.isPositiveCompletion(type(fileType))) {
this.fileType = fileType;
this.fileFormat = FTP.NON_PRINT_TEXT_FORMAT;
return true;
}
return false;
}
/**
* Sets the file type to be transferred and the format. The type should be one of FTP.ASCII_FILE_TYPE , FTP.BINARY_FILE_TYPE ,
* etc. The file type only needs to be set when you want to change the type. After changing it, the new type stays in effect until you change it again. The
* default file type is FTP.ASCII_FILE_TYPE if this method is never called.
* The server default is supposed to be ASCII (see RFC 959), however many ftp servers default to BINARY. To ensure correct operation with all servers,
* always specify the appropriate file type after connecting to the server.
* The format should be one of the FTP class TEXT_FORMAT constants, or if the type is FTP.LOCAL_FILE_TYPE , the format should
* be the byte size for that type. The default format is FTP.NON_PRINT_TEXT_FORMAT if this method is never called.
* _FILE_TYPE constant indicating the type of file.
* @param formatOrByteSize The format of the file (one of the _FORMAT constants. In the case of LOCAL_FILE_TYPE, the byte size.
*
* @return True if successfully completed, false if not.
* @throws FTPConnectionClosedException If the FTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send FTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
*/
public boolean setFileType(final int fileType, final int formatOrByteSize) throws IOException {
if (FTPReply.isPositiveCompletion(type(fileType, formatOrByteSize))) {
this.fileType = fileType;
this.fileFormat = formatOrByteSize;
return true;
}
return false;
}
/**
* Sets whether the IP address from the server's response should be used. Until 3.9.0, this has always been the case. Beginning with 3.9.0, that IP address
* will be silently ignored, and replaced with the remote IP address of the control connection, unless this configuration option is given, which restores
* the old behavior. To enable this by default, use the system property {@link FTPClient#FTP_IP_ADDRESS_FROM_PASV_RESPONSE}.
*
* @param usingIpAddressFromPasvResponse True, if the IP address from the server's response should be used (pre-3.9.0 compatible behavior), or false (ignore
* that IP address).
* @see FTPClient#FTP_IP_ADDRESS_FROM_PASV_RESPONSE
* @see #isIpAddressFromPasvResponse
* @since 3.9.0
*/
public void setIpAddressFromPasvResponse(final boolean usingIpAddressFromPasvResponse) {
this.ipAddressFromPasvResponse = usingIpAddressFromPasvResponse;
}
/**
* You can set this to true if you would like to get hidden files when {@link #listFiles} too. A LIST -a will be issued to the ftp server. It
* depends on your ftp server if you need to call this method, also dont expect to get rid of hidden files if you call this method with "false".
*
* @param listHiddenFiles true if hidden files should be listed
* @since 2.0
*/
public void setListHiddenFiles(final boolean listHiddenFiles) {
this.listHiddenFiles = listHiddenFiles;
}
/**
* Issue the FTP MFMT command (not supported by all servers) which sets the last modified time of a file.
*
* The timestamp should be in the form yyyyMMDDhhmmss. It should also be in GMT, but not all servers honor this.
*
* An FTP server would indicate its support of this feature by including "MFMT" in its response to the FEAT command, which may be retrieved by
* FTPClient.features()
*
* @param pathname The file path for which last modified time is to be changed.
* @param timeval The timestamp to set to, in yyyyMMDDhhmmss format.
* @return true if successfully set, false if not
* @throws IOException if an I/O error occurs.
* @since 2.2
* @see http://tools.ietf.org/html/draft-somers-ftp-mfxx-04
*/
public boolean setModificationTime(final String pathname, final String timeval) throws IOException {
return (FTPReply.isPositiveCompletion(mfmt(pathname, timeval)));
}
/**
* set the factory used for parser creation to the supplied factory object.
*
* @param parserFactory factory object used to create FTPFileEntryParsers
*
* @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
* @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
*/
public void setParserFactory(final FTPFileEntryParserFactory parserFactory) {
this.parserFactory = parserFactory;
}
/**
* Set the local IP address to use in passive mode. Useful when there are multiple network cards.
*
* @param inetAddress The local IP address of this machine.
*/
public void setPassiveLocalIPAddress(final InetAddress inetAddress) {
this.passiveLocalHost = inetAddress;
}
/**
* Set the local IP address to use in passive mode. Useful when there are multiple network cards.
*
* @param ipAddress The local IP address of this machine.
* @throws UnknownHostException if the ipAddress cannot be resolved
*/
public void setPassiveLocalIPAddress(final String ipAddress) throws UnknownHostException {
this.passiveLocalHost = InetAddress.getByName(ipAddress);
}
/**
* Enables or disables passive mode NAT workaround. If enabled, a site-local PASV mode reply address will be replaced with the remote host address to which
* the PASV mode request was sent (unless that is also a site local address). This gets around the problem that some NAT boxes may change the reply.
* Examples of use of FTPClientConfig
Use cases: You are trying to access a server that
*
*
* MM dd yyyyMMM d yyyy date formatting
*
*
* FTPClient f = FTPClient();
* FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
* conf.setServerLanguageCode("fr");
* f.configure(conf);
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = listFiles(directory);
*
*
* FTPClient f = FTPClient();
* FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
* conf.setServerLanguageCode("da");
* conf.setDefaultDateFormat("d MMM yyyy");
* conf.setRecentDateFormat("d MMM HH:mm");
* conf.setTimeZoneId("Europe/Copenhagen");
* f.configure(conf);
* f.connect(server);
* f.login(username, password);
* FTPListParseEngine engine = f.initiateListParsing("com.whatever.YourOwnParser", directory);
*
* while (engine.hasNext()) {
* FTPFile[] files = engine.getNext(25); // "page size" you want
* // do whatever you want with these files, display them, etc.
* // expensive FTPFile objects not created until needed.
* }
*
* MMM d yyyy date formatting
*
*
* FTPClient f = FTPClient();
* FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_VMS);
* conf.setShortMonthNames("jan|feb|mar|apr|ma\u00ED|j\u00FAn|j\u00FAl|\u00e1g\u00FA|sep|okt|n\u00F3v|des");
* f.configure(conf);
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = listFiles(directory);
*
*
* FTPClient f = FTPClient();
* FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
* conf.setTimeZoneId("America/Denver");
* f.configure(conf);
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = listFiles(directory);
*
*
* Unpaged (whole list) access on a Windows-NT server in a different time zone but which has been configured to use a unix-style listing format.
*
*
* FTPClient f = FTPClient();
* FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
* conf.setTimeZoneId("America/Denver");
* f.configure(conf);
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = listFiles(directory);
*
*
* @since 1.4
* @see org.apache.commons.net.ftp.Configurable
* @see org.apache.commons.net.ftp.FTPClient
* @see org.apache.commons.net.ftp.parser.FTPTimestampParserImpl#configure(FTPClientConfig)
* @see org.apache.commons.net.ftp.parser.ConfigurableFTPFileEntryParserImpl
*/
public class FTPClientConfig {
/**
* Identifier by which a unix-based ftp server is known throughout the commons-net ftp system.
*/
public static final String SYST_UNIX = "UNIX";
/**
* Identifier for alternate UNIX parser; same as {@link #SYST_UNIX} but leading spaces are trimmed from file names. This is to maintain backwards
* compatibility with the original behavior of the parser which ignored multiple spaces between the date and the start of the file name.
*
* @since 3.4
*/
public static final String SYST_UNIX_TRIM_LEADING = "UNIX_LTRIM";
/**
* Identifier by which a vms-based ftp server is known throughout the commons-net ftp system.
*/
public static final String SYST_VMS = "VMS";
/**
* Identifier by which a WindowsNT-based ftp server is known throughout the commons-net ftp system.
*/
public static final String SYST_NT = "WINDOWS";
/**
* Identifier by which an OS/2-based ftp server is known throughout the commons-net ftp system.
*/
public static final String SYST_OS2 = "OS/2";
/**
* Identifier by which an OS/400-based ftp server is known throughout the commons-net ftp system.
*/
public static final String SYST_OS400 = "OS/400";
/**
* Identifier by which an AS/400-based ftp server is known throughout the commons-net ftp system.
*/
public static final String SYST_AS400 = "AS/400";
/**
* Identifier by which an MVS-based ftp server is known throughout the commons-net ftp system.
*/
public static final String SYST_MVS = "MVS";
/**
* Some servers return an "UNKNOWN Type: L8" message in response to the SYST command. We set these to be a Unix-type system. This may happen if the ftpd in
* question was compiled without system information.
*
* NET-230 - Updated to be UPPERCASE so that the check done in createFileEntryParser will succeed.
*
* @since 1.5
*/
public static final String SYST_L8 = "TYPE: L8";
/**
* Identifier by which an Netware-based ftp server is known throughout the commons-net ftp system.
*
* @since 1.5
*/
public static final String SYST_NETWARE = "NETWARE";
/**
* Identifier by which a Mac pre OS-X -based ftp server is known throughout the commons-net ftp system.
*
* @since 3.1
*/
// Full string is "MACOS Peter's Server"; the substring below should be enough
public static final String SYST_MACOS_PETER = "MACOS PETER"; // NET-436
private static final MapLocale.US
*
* @param languageCode See {@link #setServerLanguageCode(String) serverLanguageCode}
* @return a DateFormatSymbols object configured with short month names corresponding to the supplied code, or with month names for Locale.US
* if there is no corresponding entry in the internal table.
*/
public static DateFormatSymbols lookupDateFormatSymbols(final String languageCode) {
final Object lang = LANGUAGE_CODE_MAP.get(languageCode);
if (lang != null) {
if (lang instanceof Locale) {
return new DateFormatSymbols((Locale) lang);
}
if (lang instanceof String) {
return getDateFormatSymbols((String) lang);
}
}
return new DateFormatSymbols(Locale.US);
}
private static String[] splitShortMonthString(final String shortmonths) {
final StringTokenizer st = new StringTokenizer(shortmonths, "|");
final int monthcnt = st.countTokens();
if (12 != monthcnt) {
throw new IllegalArgumentException("expecting a pipe-delimited string containing 12 tokens");
}
final String[] months = new String[13];
int pos = 0;
while (st.hasMoreTokens()) {
months[pos++] = st.nextToken();
}
months[pos] = "";
return months;
}
private final String serverSystemKey;
private String defaultDateFormatStr;
private String recentDateFormatStr;
private boolean lenientFutureDates = true; // NET-407
private String serverLanguageCode;
private String shortMonthNames;
private String serverTimeZoneId;
private boolean saveUnparseableEntries;
/**
* Convenience constructor mainly for use in testing. Constructs a UNIX configuration.
*/
public FTPClientConfig() {
this(SYST_UNIX);
}
/**
* Copy constructor
*
* @param config source
* @since 3.6
*/
public FTPClientConfig(final FTPClientConfig config) {
this.serverSystemKey = config.serverSystemKey;
this.defaultDateFormatStr = config.defaultDateFormatStr;
this.lenientFutureDates = config.lenientFutureDates;
this.recentDateFormatStr = config.recentDateFormatStr;
this.saveUnparseableEntries = config.saveUnparseableEntries;
this.serverLanguageCode = config.serverLanguageCode;
this.serverTimeZoneId = config.serverTimeZoneId;
this.shortMonthNames = config.shortMonthNames;
}
/**
* The main constructor for an FTPClientConfig object
*
* @param systemKey key representing system type of the server being connected to. See {@link #getServerSystemKey() serverSystemKey} If set to the empty
* string, then FTPClient uses the system type returned by the server. However this is not recommended for general use; the correct system
* type should be set if it is known.
*/
public FTPClientConfig(final String systemKey) {
this.serverSystemKey = systemKey;
}
// Copy constructor, intended for use by FTPClient only
FTPClientConfig(final String systemKey, final FTPClientConfig config) {
this.serverSystemKey = systemKey;
this.defaultDateFormatStr = config.defaultDateFormatStr;
this.lenientFutureDates = config.lenientFutureDates;
this.recentDateFormatStr = config.recentDateFormatStr;
this.saveUnparseableEntries = config.saveUnparseableEntries;
this.serverLanguageCode = config.serverLanguageCode;
this.serverTimeZoneId = config.serverTimeZoneId;
this.shortMonthNames = config.shortMonthNames;
}
/**
* Constructor which allows setting of the format string member fields
*
* @param systemKey key representing system type of the server being connected to. See {@link #getServerSystemKey() serverSystemKey}
* @param defaultDateFormatStr See {@link #setDefaultDateFormatStr(String) defaultDateFormatStr}
* @param recentDateFormatStr See {@link #setRecentDateFormatStr(String) recentDateFormatStr}
* @since 3.6
*/
public FTPClientConfig(final String systemKey, final String defaultDateFormatStr, final String recentDateFormatStr) {
this(systemKey);
this.defaultDateFormatStr = defaultDateFormatStr;
this.recentDateFormatStr = recentDateFormatStr;
}
/**
* Constructor which allows setting of most member fields
*
* @param systemKey key representing system type of the server being connected to. See {@link #getServerSystemKey() serverSystemKey}
* @param defaultDateFormatStr See {@link #setDefaultDateFormatStr(String) defaultDateFormatStr}
* @param recentDateFormatStr See {@link #setRecentDateFormatStr(String) recentDateFormatStr}
* @param serverLanguageCode See {@link #setServerLanguageCode(String) serverLanguageCode}
* @param shortMonthNames See {@link #setShortMonthNames(String) shortMonthNames}
* @param serverTimeZoneId See {@link #setServerTimeZoneId(String) serverTimeZoneId}
*/
public FTPClientConfig(final String systemKey, final String defaultDateFormatStr, final String recentDateFormatStr, final String serverLanguageCode,
final String shortMonthNames, final String serverTimeZoneId) {
this(systemKey);
this.defaultDateFormatStr = defaultDateFormatStr;
this.recentDateFormatStr = recentDateFormatStr;
this.serverLanguageCode = serverLanguageCode;
this.shortMonthNames = shortMonthNames;
this.serverTimeZoneId = serverTimeZoneId;
}
/**
* Constructor which allows setting of all member fields
*
* @param systemKey key representing system type of the server being connected to. See {@link #getServerSystemKey() serverSystemKey}
* @param defaultDateFormatStr See {@link #setDefaultDateFormatStr(String) defaultDateFormatStr}
* @param recentDateFormatStr See {@link #setRecentDateFormatStr(String) recentDateFormatStr}
* @param serverLanguageCode See {@link #setServerLanguageCode(String) serverLanguageCode}
* @param shortMonthNames See {@link #setShortMonthNames(String) shortMonthNames}
* @param serverTimeZoneId See {@link #setServerTimeZoneId(String) serverTimeZoneId}
* @param lenientFutureDates See {@link #setLenientFutureDates(boolean) lenientFutureDates}
* @param saveUnparseableEntries See {@link #setUnparseableEntries(boolean) saveUnparseableEntries}
*/
public FTPClientConfig(final String systemKey, final String defaultDateFormatStr, final String recentDateFormatStr, final String serverLanguageCode,
final String shortMonthNames, final String serverTimeZoneId, final boolean lenientFutureDates, final boolean saveUnparseableEntries) {
this(systemKey);
this.defaultDateFormatStr = defaultDateFormatStr;
this.lenientFutureDates = lenientFutureDates;
this.recentDateFormatStr = recentDateFormatStr;
this.saveUnparseableEntries = saveUnparseableEntries;
this.serverLanguageCode = serverLanguageCode;
this.shortMonthNames = shortMonthNames;
this.serverTimeZoneId = serverTimeZoneId;
}
/**
* getter for the {@link #setDefaultDateFormatStr(String) defaultDateFormatStr} property.
*
* @return Returns the defaultDateFormatStr property.
*/
public String getDefaultDateFormatStr() {
return defaultDateFormatStr;
}
/**
* getter for the {@link #setRecentDateFormatStr(String) recentDateFormatStr} property.
*
* @return Returns the recentDateFormatStr property.
*/
public String getRecentDateFormatStr() {
return recentDateFormatStr;
}
/**
* FTPClientConfig.SYST_* codes or else the fully qualified class name of a parser implementing both the FTPFileEntryParser and
* Configurable interfaces.
*
* @return Returns the serverSystemKey property.
*/
public String getServerSystemKey() {
return serverSystemKey;
}
/**
* getter for the {@link #setServerTimeZoneId(String) serverTimeZoneId} property.
*
* @return Returns the serverTimeZoneId property.
*/
public String getServerTimeZoneId() {
return serverTimeZoneId;
}
/**
* en_US locales.
* java.text.SimpleDateFormat. property.
* java.text.SimpleDateFormat.
* en_US month names will be used. We are supporting here those language codes which, when a
* java.util.Locale is constucted using it, and a java.text.SimpleDateFormat is constructed using that Locale, the array returned
* by the SimpleDateFormat's getShortMonths() method consists solely of three 8-bit ASCII character strings. Additionally, languages which do
* not meet this requirement are included if a common alternative set of short month names is known to be used. This means that users who can tell us of
* additional such encodings may get them added to the list of supported languages by contacting the Apache Commons Net team.
* en_US date format orderings of MMM d yyyy and
* MMM d HH:mm and attempting to deduce this automatically here would cause more problems than it would solve. The date format must be changed
* via the {@link #setDefaultDateFormatStr(String) defaultDateFormatStr} and/or {@link #setRecentDateFormatStr(String) recentDateFormatStr} parameters.
* java.util.TimeZone to refer to time zones, for example, America/Chicago or
* Asia/Rangoon.
* "jan|feb|mar|apr|maí|jún|júl|ágú|sep|okt|nóv|des".
* _TYPE constants), e.g., if it is a directory, a regular file, or a symbolic link.
*
* @return The type of the file.
*/
public int getType() {
return type;
}
/**
* Gets the name of the user owning the file. Sometimes this will be a string representation of the user number.
*
* @return The name of the user owning the file.
*/
public String getUser() {
return user;
}
/**
* Tests if the given access group (one of the _ACCESS constants) has the given access permission (one of the _PERMISSION
* constants) to the file.
*
* @param access The access group (one of the _ACCESS constants)
* @param permission The access permission (one of the _PERMISSION constants)
* @throws ArrayIndexOutOfBoundsException if either of the parameters is out of range
* @return true if {@link #isValid()} is {@code true &&} the associated permission is set; {@code false} otherwise.
*/
public boolean hasPermission(final int access, final int permission) {
if (permissions == null) {
return false;
}
return permissions[access][permission];
}
/**
* Tests if the file is a directory.
*
* @return True if the file is of type DIRECTORY_TYPE, false if not.
*/
public boolean isDirectory() {
return type == DIRECTORY_TYPE;
}
/**
* Tests if the file is a regular file.
*
* @return True if the file is of type FILE_TYPE, false if not.
*/
public boolean isFile() {
return type == FILE_TYPE;
}
/**
* Tests if the file is a symbolic link.
*
* @return True if the file is of type UNKNOWN_TYPE, false if not.
*/
public boolean isSymbolicLink() {
return type == SYMBOLIC_LINK_TYPE;
}
/**
* Tests if the type of the file is unknown.
*
* @return True if the file is of type UNKNOWN_TYPE, false if not.
*/
public boolean isUnknown() {
return type == UNKNOWN_TYPE;
}
/**
* Tests whether an entry is valid or not. If the entry is invalid, only the {@link #getRawListing()} method will be useful. Other methods may fail.
*
* Used in conjunction with list parsing that preseverves entries that failed to parse.
*
* @see FTPClientConfig#setUnparseableEntries(boolean)
* @return true if the entry is valid
* @since 3.4
*/
public boolean isValid() {
return permissions != null;
}
private String permissionToString(final int access) {
final StringBuilder sb = new StringBuilder();
if (hasPermission(access, READ_PERMISSION)) {
sb.append('r');
} else {
sb.append('-');
}
if (hasPermission(access, WRITE_PERMISSION)) {
sb.append('w');
} else {
sb.append('-');
}
if (hasPermission(access, EXECUTE_PERMISSION)) {
sb.append('x');
} else {
sb.append('-');
}
return sb.toString();
}
private void readObject(final java.io.ObjectInputStream in) {
throw new UnsupportedOperationException("Serialization is not supported");
}
/**
* Sets the name of the group owning the file. This may be a string representation of the group number.
*
* @param group The name of the group owning the file.
*/
public void setGroup(final String group) {
this.group = group;
}
/**
* Sets the number of hard links to this file. This is not to be confused with symbolic links.
*
* @param links The number of hard links to this file.
*/
public void setHardLinkCount(final int links) {
this.hardLinkCount = links;
}
/**
* If the FTPFile is a symbolic link, use this method to set the name of the file being pointed to by the symbolic link.
*
* @param link The file pointed to by the symbolic link.
*/
public void setLink(final String link) {
this.link = link;
}
/**
* Sets the name of the file.
*
* @param name The name of the file.
*/
public void setName(final String name) {
this.name = name;
}
/**
* Sets if the given access group (one of the _ACCESS constants) has the given access permission (one of the _PERMISSION
* constants) to the file.
*
* @param access The access group (one of the _ACCESS constants)
* @param permission The access permission (one of the _PERMISSION constants)
* @param value True if permission is allowed, false if not.
* @throws ArrayIndexOutOfBoundsException if either of the parameters is out of range
*/
public void setPermission(final int access, final int permission, final boolean value) {
permissions[access][permission] = value;
}
/**
* Sets the original FTP server raw listing from which the FTPFile was created.
*
* @param rawListing The raw FTP server listing.
*/
public void setRawListing(final String rawListing) {
this.rawListing = rawListing;
}
/**
* Sets the file size in bytes.
*
* @param size The file size in bytes.
*/
public void setSize(final long size) {
this.size = size;
}
/**
* Sets the file timestamp. This usually the last modification time. The parameter is not cloned, so do not alter its value after calling this method.
*
* @param date A Calendar instance representing the file timestamp.
*/
public void setTimestamp(final Calendar date) {
this.calendar = date;
}
/**
* Sets the type of the file (DIRECTORY_TYPE, FILE_TYPE, etc.).
*
* @param type The integer code representing the type of the file.
*/
public void setType(final int type) {
this.type = type;
}
/**
* Sets the name of the user owning the file. This may be a string representation of the user number;
*
* @param user The name of the user owning the file.
*/
public void setUser(final String user) {
this.user = user;
}
/**
* Gets a string representation of the FTPFile information. This currently mimics the Unix listing format. This method uses the time zone of the Calendar
* entry, which is the server time zone (if one was provided) otherwise it is the local time zone.
* FTPClient.listFiles() API to pull the whole list from the subfolder subfolder in one call, attempting to
* automatically detect the parser type. This method, without a parserKey parameter, indicates that autodection should be used.
*
*
* FTPClient f = FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = f.listFiles("subfolder");
*
*
* The second example uses the FTPClient.listFiles() API to pull the whole list from the current working directory in one call, but specifying by
* classname the parser to be used. For this particular parser class, this approach is necessary since there is no way to autodetect this server type.
*
*
* FTPClient f = FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = f.listFiles("org.apache.commons.net.ftp.parser.EnterpriseUnixFTPFileEntryParser", ".");
*
*
* The third example uses the FTPClient.listFiles() API to pull a single file listing in an arbitrary directory in one call, specifying by KEY the
* parser to be used, in this case, VMS.
*
*
* FTPClient f = FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPFile[] files = f.listFiles("VMS", "subfolder/foo.java");
*
*
* For an alternative approach, see the {@link FTPListParseEngine} class which provides iterative access.
*
* @see org.apache.commons.net.ftp.FTPFile
* @see org.apache.commons.net.ftp.FTPClient#listFiles()
*/
public interface FTPFileEntryParser {
/**
* Parses a line of an FTP server file listing and converts it into a usable format in the form of an FTPFile instance. If the file listing
* line doesn't describe a file, null should be returned, otherwise a FTPFile instance representing the files in the directory
* is returned.
*
* @param listEntry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
FTPFile parseFTPEntry(String listEntry);
/**
* This method is a hook for those implementors (such as VMSVersioningFTPEntryParser, and possibly others) which need to perform some action upon the
* FTPFileList after it has been created from the server stream, but before any clients see the list.
*
* The default implementation can be a no-op.
*
* @param original Original list after it has been created from the server stream
*
* @return Original list as processed by this method.
*/
Listoriginal unmodified.
*/
@Override
public ListreadNextEntry() - which handles the issue of what delimits one entry from another, usually but not always a
* line feed and preParse() - which handles removal of extraneous matter such as the preliminary lines of a listing, removal of duplicates on
* versioning systems, etc.
* getNext() and getPrevious() methods to
* provide "paged" output of less than the whole list at one time, or by calling the getFiles() method to return the entire list.
*
* FTPClient f = FTPClient();
* f.connect(server);
* f.login(username, password);
* FTPListParseEngine engine = f.initiateListParsing(directory);
*
* while (engine.hasNext()) {
* FTPFile[] files = engine.getNext(25); // "page size" you want
* // do whatever you want with these files, display them, etc.
* // expensive FTPFile objects not created until needed.
* }
*
* null.
*
* @return a list of FTPFile objects containing the whole list of files returned by the server as read by this object's parser.
* null.
*
* @return an array of FTPFile objects containing the whole list of files returned by the server as read by this object's parser.
* quantityRequested FTPFile objects starting at this object's internal iterator's current position. If fewer than
* quantityRequested such elements are available, the returned array will have a length equal to the number of entries at and after after the
* current position. If no such entries are found, this array will have a length of 0.
*
* After this method is called this object's internal iterator is advanced by a number of positions equal to the size of the array returned.
*
* @param quantityRequested the maximum number of entries we want to get.
*
* @return an array of at most quantityRequested FTPFile objects starting at the current position of this iterator within its list and at least
* the number of elements which exist in the list at and after its current position.
* quantityRequested FTPFile objects starting at this object's internal iterator's current position, and working
* back toward the beginning.
*
* If fewer than quantityRequested such elements are available, the returned array will have a length equal to the number of entries at and
* after after the current position. If no such entries are found, this array will have a length of 0.
*
* After this method is called this object's internal iterator is moved back by a number of positions equal to the size of the array returned.
*
* @param quantityRequested the maximum number of entries we want to get.
*
* @return an array of at most quantityRequested FTPFile objects starting at the current position of this iterator within its list and at least
* the number of elements which exist in the list at and after its current position. This array will be in the same order as the underlying list
* (not reversed).
* entries list. After this method has completed, entries will
* contain a collection of entries (as defined by FTPFileEntryParser.readNextEntry()), but this may contain various non-entry preliminary lines
* from the server output, duplicates, and other data that will not be part of the final listing.
*
* @param inputStream The socket stream on which the input will be read.
* @param charsetName The encoding to use.
*
* @throws IOException thrown on any failure to read the stream
*/
private void read(final InputStream inputStream, final String charsetName) throws IOException {
try (final BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, Charsets.toCharset(charsetName)))) {
String line = this.parser.readNextEntry(reader);
while (line != null) {
this.entries.add(line);
line = this.parser.readNextEntry(reader);
}
}
}
/**
* Do not use.
*
* @param inputStream the stream from which to read
* @throws IOException on error
* @deprecated use {@link #readServerList(InputStream, String)} instead
*/
@Deprecated
public void readServerList(final InputStream inputStream) throws IOException {
readServerList(inputStream, null);
}
/**
* Reads (and closes) the initial reading and preparsing of the list returned by the server. After this method has completed, this object will contain a
* list of unparsed entries (Strings) each referring to a unique file on the server.
*
* @param inputStream input stream provided by the server socket.
* @param charsetName the encoding to be used for reading the stream
*
* @throws IOException thrown on any failure to read from the sever.
*/
public void readServerList(final InputStream inputStream, final String charsetName) throws IOException {
this.entries = new LinkedList<>();
read(inputStream, charsetName);
this.parser.preParse(this.entries);
resetIterator();
}
// DEPRECATED METHODS - for API compatibility only - DO NOT USE
/**
* resets this object's internal iterator to the beginning of the list.
*/
public void resetIterator() {
this.internalIterator = this.entries.listIterator();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPReply.java 0000664 0000000 0000000 00000017221 14340477222 0031015 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
/**
* FTPReply stores a set of constants for FTP reply 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.
*
*
* N.B. the method calls {@link #setSocketFactory(javax.net.SocketFactory)} and {@link #setServerSocketFactory(javax.net.ServerSocketFactory)}
*
* @param prot Data Channel Protection Level, if {@code null}, use {@link #DEFAULT_PROT}.
* @throws SSLException If the server reply code does not equal {@code 200}.
* @throws IOException If an I/O error occurs while sending the command.
*/
public void execPROT(String prot) throws SSLException, IOException {
if (prot == null) {
prot = DEFAULT_PROT;
}
if (!checkPROTValue(prot)) {
throw new IllegalArgumentException();
}
if (FTPReply.COMMAND_OK != sendCommand(CMD_PROT, prot)) {
throw new SSLException(getReplyString());
}
if (DEFAULT_PROT.equals(prot)) {
setSocketFactory(null);
setServerSocketFactory(null);
} else {
setSocketFactory(new FTPSSocketFactory(context));
setServerSocketFactory(new FTPSServerSocketFactory(context));
initSslContext();
}
}
/**
* Extract the data from a reply with a prefix, e.g. PBSZ=1234 => 1234
*
* @param prefix the prefix to find
* @param reply where to find the prefix
* @return the remainder of the string after the prefix, or null if the prefix was not present.
*/
private String extractPrefixedData(final String prefix, final String reply) {
final int idx = reply.indexOf(prefix);
if (idx == -1) {
return null;
}
// N.B. Cannot use trim before substring as leading space would affect the offset.
return reply.substring(idx + prefix.length()).trim();
}
/**
* Return AUTH command use value.
*
* @return AUTH command use value.
*/
public String getAuthValue() {
return this.auth;
}
/**
* Returns the names of the cipher suites which could be enabled for use on this connection. When the underlying {@link Socket} is not an {@link SSLSocket}
* instance, returns null.
*
* @return An array of cipher suite names, or null
*/
public String[] getEnabledCipherSuites() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledCipherSuites();
}
return null;
}
/**
* Returns the names of the protocol versions which are currently enabled for use on this connection. When the underlying {@link Socket} is not an
* {@link SSLSocket} instance, returns null.
*
* @return An array of protocols, or null
*/
public String[] getEnabledProtocols() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledProtocols();
}
return null;
}
/**
* Returns true if new SSL sessions may be established by this socket. When the underlying {@link Socket} instance is not SSL-enabled (i.e. an instance of
* {@link SSLSocket} with {@link SSLSocket}{@link #getEnableSessionCreation()}) enabled, this returns False.
*
* @return true - Indicates that sessions may be created; this is the default. false - indicates that an existing session must be resumed.
*/
public boolean getEnableSessionCreation() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnableSessionCreation();
}
return false;
}
/**
* Get the currently configured {@link HostnameVerifier}. The verifier is only used on client mode connections.
*
* @return A HostnameVerifier instance.
* @since 3.4
*/
public HostnameVerifier getHostnameVerifier() {
return hostnameVerifier;
}
/**
* Gets the {@link KeyManager} instance.
*
* @return The {@link KeyManager} instance
*/
private KeyManager getKeyManager() {
return keyManager;
}
/**
* Returns true if the socket will require client authentication. When the underlying {@link Socket} is not an {@link SSLSocket} instance, returns false.
*
* @return true - If the server mode socket should request that the client authenticate itself.
*/
public boolean getNeedClientAuth() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getNeedClientAuth();
}
return false;
}
/**
* Get the currently configured {@link TrustManager}.
*
* @return A TrustManager instance.
*/
public TrustManager getTrustManager() {
return trustManager;
}
/**
* Returns true if the socket is set to use client mode in its first handshake. When the underlying {@link Socket} is not an {@link SSLSocket} instance,
* returns false.
*
* @return true - If the socket should start its first handshake in "client" mode.
*/
public boolean getUseClientMode() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getUseClientMode();
}
return false;
}
/**
* Returns true if the socket will request client authentication. When the underlying {@link Socket} is not an {@link SSLSocket} instance, returns false.
*
* @return true - If the server mode socket should request that the client authenticate itself.
*/
public boolean getWantClientAuth() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getWantClientAuth();
}
return false;
}
/**
* Performs a lazy init of the SSL context
*
* @throws IOException
*/
private void initSslContext() throws IOException {
if (context == null) {
context = SSLContextUtils.createSSLContext(protocol, getKeyManager(), getTrustManager());
}
}
/**
* Return whether or not endpoint identification using the HTTPS algorithm on Java 1.7+ is enabled. The default behavior is for this to be disabled.
*
* This check is only performed on client mode connections.
*
* @return True if enabled, false if not.
* @since 3.4
*/
public boolean isEndpointCheckingEnabled() {
return tlsEndpointChecking;
}
/**
* Establishes a data connection with the FTP server, returning a Socket for the connection if successful. If a restart offset has been set with
* {@link #setRestartOffset(long)}, a REST command is issued to the server with the offset as an argument before establishing the data connection. Active
* mode connections also cause a local PORT command to be issued.
*
* @param command The text representation of the FTP command to send.
* @param arg The arguments to the FTP command. If this parameter is set to null, then the command is sent with no argument.
* @return A Socket corresponding to the established data connection. Null is returned if an FTP protocol error is reported at any point during the
* establishment and initialization of the connection.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @since 3.1
*/
private Socket openDataSecureConnection(final String command, final String arg) throws IOException {
if (getDataConnectionMode() != ACTIVE_LOCAL_DATA_CONNECTION_MODE && getDataConnectionMode() != PASSIVE_LOCAL_DATA_CONNECTION_MODE) {
return null;
}
final boolean isInet6Address = getRemoteAddress() instanceof Inet6Address;
final Socket socket;
Socket sslSocket = null;
final int soTimeoutMillis = DurationUtils.toMillisInt(getDataTimeout());
if (getDataConnectionMode() == ACTIVE_LOCAL_DATA_CONNECTION_MODE) {
// if no activePortRange was set (correctly) -> getActivePort() = 0
// -> new ServerSocket(0) -> bind to any free local port
try (final ServerSocket server = _serverSocketFactory_.createServerSocket(getActivePort(), 1, getHostAddress())) {
// Try EPRT only if remote server is over IPv6, if not use PORT,
// because EPRT has no advantage over PORT on IPv4.
// It could even have the disadvantage,
// that EPRT will make the data connection fail, because
// today's intelligent NAT Firewalls are able to
// substitute IP addresses in the PORT command,
// but might not be able to recognize the EPRT command.
if (isInet6Address) {
if (!FTPReply.isPositiveCompletion(eprt(getReportHostAddress(), server.getLocalPort()))) {
return null;
}
} else if (!FTPReply.isPositiveCompletion(port(getReportHostAddress(), server.getLocalPort()))) {
return null;
}
if ((getRestartOffset() > 0) && !restart(getRestartOffset())) {
return null;
}
if (!FTPReply.isPositivePreliminary(sendCommand(command, arg))) {
return null;
}
// For now, let's just use the data timeout value for waiting for
// the data connection. It may be desirable to let this be a
// separately configurable value. In any case, we really want
// to allow preventing the accept from blocking indefinitely.
if (soTimeoutMillis >= 0) {
server.setSoTimeout(soTimeoutMillis);
}
socket = server.accept();
// Ensure the timeout is set before any commands are issued on the new socket
if (soTimeoutMillis >= 0) {
socket.setSoTimeout(soTimeoutMillis);
}
if (getReceiveDataSocketBufferSize() > 0) {
socket.setReceiveBufferSize(getReceiveDataSocketBufferSize());
}
if (getSendDataSocketBufferSize() > 0) {
socket.setSendBufferSize(getSendDataSocketBufferSize());
}
}
} else { // We must be in PASSIVE_LOCAL_DATA_CONNECTION_MODE
// Try EPSV command first on IPv6 - and IPv4 if enabled.
// When using IPv4 with NAT it has the advantage
// to work with more rare configurations.
// E.g. if FTP server has a static PASV address (external network)
// and the client is coming from another internal network.
// In that case the data connection after PASV command would fail,
// while EPSV would make the client succeed by taking just the port.
final boolean attemptEPSV = isUseEPSVwithIPv4() || isInet6Address;
if (attemptEPSV && epsv() == FTPReply.ENTERING_EPSV_MODE) {
_parseExtendedPassiveModeReply(_replyLines.get(0));
} else {
if (isInet6Address) {
return null; // Must use EPSV for IPV6
}
// If EPSV failed on IPV4, revert to PASV
if (pasv() != FTPReply.ENTERING_PASSIVE_MODE) {
return null;
}
_parsePassiveModeReply(_replyLines.get(0));
}
if (getProxy() != null) {
socket = new Socket(getProxy());
} else {
socket = _socketFactory_.createSocket();
}
if (getReceiveDataSocketBufferSize() > 0) {
socket.setReceiveBufferSize(getReceiveDataSocketBufferSize());
}
if (getSendDataSocketBufferSize() > 0) {
socket.setSendBufferSize(getSendDataSocketBufferSize());
}
if (getPassiveLocalIPAddress() != null) {
socket.bind(new InetSocketAddress(getPassiveLocalIPAddress(), 0));
}
// For now, let's just use the data timeout value for waiting for
// the data connection. It may be desirable to let this be a
// separately configurable value. In any case, we really want
// to allow preventing the accept from blocking indefinitely.
if (soTimeoutMillis >= 0) {
socket.setSoTimeout(soTimeoutMillis);
}
socket.connect(new InetSocketAddress(getPassiveHost(), getPassivePort()), connectTimeout);
if (getProxy() != null) {
sslSocket = context.getSocketFactory().createSocket(socket, getPassiveHost(), getPassivePort(), true);
}
if ((getRestartOffset() > 0) && !restart(getRestartOffset())) {
closeSockets(socket, sslSocket);
return null;
}
if (!FTPReply.isPositivePreliminary(sendCommand(command, arg))) {
closeSockets(socket, sslSocket);
return null;
}
}
if (isRemoteVerificationEnabled() && !verifyRemote(socket)) {
// Grab the host before we close the socket to avoid NET-663
final InetAddress socketHost = socket.getInetAddress();
closeSockets(socket, sslSocket);
throw new IOException(
"Host attempting data connection " + socketHost.getHostAddress() + " is not same as server " + getRemoteAddress().getHostAddress());
}
return getProxy() != null ? sslSocket : socket;
}
/**
* Parses the given ADAT response line and base64-decodes the data.
*
* @param reply The ADAT reply to parse.
* @return the data in the reply, base64-decoded.
* @since 3.0
*/
public byte[] parseADATReply(final String reply) {
if (reply == null) {
return null;
}
return Base64.decodeBase64(extractPrefixedData("ADAT=", reply));
}
/**
* PBSZ command. pbsz value: 0 to (2^32)-1 decimal integer. Issues the command and parses the response to return the negotiated value.
*
* @param pbsz Protection Buffer Size.
* @throws SSLException If the server reply code does not equal "200".
* @throws IOException If an I/O error occurs while sending the command.
* @return the negotiated value.
* @see #execPBSZ(long)
* @since 3.0
*/
public long parsePBSZ(final long pbsz) throws SSLException, IOException {
execPBSZ(pbsz);
long minvalue = pbsz;
final String remainder = extractPrefixedData("PBSZ=", getReplyString());
if (remainder != null) {
final long replysz = Long.parseLong(remainder);
if (replysz < minvalue) {
minvalue = replysz;
}
}
return minvalue;
}
/**
* Send an FTP command. A successful CCC (Clear Command Channel) command causes the underlying {@link SSLSocket} instance to be assigned to a plain
* {@link Socket}
*
* @param command The FTP command.
* @return server reply.
* @throws IOException If an I/O error occurs while sending the command.
* @throws SSLException if a CCC command fails
* @see org.apache.commons.net.ftp.FTP#sendCommand(String)
*/
// Would like to remove this method, but that will break any existing clients that are using CCC
@Override
public int sendCommand(final String command, final String args) throws IOException {
final int repCode = super.sendCommand(command, args);
/* If CCC is issued, restore socket i/o streams to unsecured versions */
if (CMD_CCC.equals(command)) {
if (FTPReply.COMMAND_OK != repCode) {
throw new SSLException(getReplyString());
}
_socket_.close();
_socket_ = plainSocket;
_controlInput_ = new BufferedReader(new InputStreamReader(_socket_.getInputStream(), getControlEncoding()));
_controlOutput_ = new BufferedWriter(new OutputStreamWriter(_socket_.getOutputStream(), getControlEncoding()));
}
return repCode;
}
/**
* Set AUTH command use value. This processing is done before connected processing.
*
* @param auth AUTH command use value.
*/
public void setAuthValue(final String auth) {
this.auth = auth;
}
/**
* Controls which particular cipher suites are enabled for use on this connection. Called before server negotiation.
*
* @param cipherSuites The cipher suites.
*/
public void setEnabledCipherSuites(final String[] cipherSuites) {
suites = cipherSuites.clone();
}
/**
* Controls which particular protocol versions are enabled for use on this connection. I perform setting before a server negotiation.
*
* @param protocolVersions The protocol versions.
*/
public void setEnabledProtocols(final String[] protocolVersions) {
protocols = protocolVersions.clone();
}
/**
* Controls whether a new SSL session may be established by this socket.
*
* @param isCreation The established socket flag.
*/
public void setEnabledSessionCreation(final boolean isCreation) {
this.isCreation = isCreation;
}
/**
* Automatic endpoint identification checking using the HTTPS algorithm is supported on Java 1.7+. The default behavior is for this to be disabled.
*
* This check is only performed on client mode connections.
*
* @param enable Enable automatic endpoint identification checking using the HTTPS algorithm on Java 1.7+.
* @since 3.4
*/
public void setEndpointCheckingEnabled(final boolean enable) {
tlsEndpointChecking = enable;
}
/**
* Override the default {@link HostnameVerifier} to use. The verifier is only used on client mode connections.
*
* @param newHostnameVerifier The HostnameVerifier implementation to set or null to disable.
* @since 3.4
*/
public void setHostnameVerifier(final HostnameVerifier newHostnameVerifier) {
hostnameVerifier = newHostnameVerifier;
}
/**
* Set a {@link KeyManager} to use
*
* @param keyManager The KeyManager implementation to set.
* @see org.apache.commons.net.util.KeyManagerUtils
*/
public void setKeyManager(final KeyManager keyManager) {
this.keyManager = keyManager;
}
// DEPRECATED - for API compatibility only - DO NOT USE
/**
* Configures the socket to require client authentication.
*
* @param isNeedClientAuth The need client auth flag.
*/
public void setNeedClientAuth(final boolean isNeedClientAuth) {
this.isNeedClientAuth = isNeedClientAuth;
}
/**
* Override the default {@link TrustManager} to use; if set to {@code null}, the default TrustManager from the JVM will be used.
*
* @param trustManager The TrustManager implementation to set, may be {@code null}
* @see org.apache.commons.net.util.TrustManagerUtils
*/
public void setTrustManager(final TrustManager trustManager) {
this.trustManager = trustManager;
}
/**
* Configures the socket to use client (or server) mode in its first handshake.
*
* @param isClientMode The use client mode flag.
*/
public void setUseClientMode(final boolean isClientMode) {
this.isClientMode = isClientMode;
}
/**
* Configures the socket to request client authentication, but only if such a request is appropriate to the cipher suite negotiated.
*
* @param isWantClientAuth The want client auth flag.
*/
public void setWantClientAuth(final boolean isWantClientAuth) {
this.isWantClientAuth = isWantClientAuth;
}
/**
* SSL/TLS negotiation. Acquires an SSL socket of a control connection and carries out handshake processing.
*
* @throws IOException If server negotiation fails
*/
protected void sslNegotiation() throws IOException {
plainSocket = _socket_;
initSslContext();
final SSLSocket socket = createSSLSocket(_socket_);
socket.setEnableSessionCreation(isCreation);
socket.setUseClientMode(isClientMode);
// client mode
if (isClientMode) {
if (tlsEndpointChecking) {
SSLSocketUtils.enableEndpointNameVerification(socket);
}
} else { // server mode
socket.setNeedClientAuth(isNeedClientAuth);
socket.setWantClientAuth(isWantClientAuth);
}
if (protocols != null) {
socket.setEnabledProtocols(protocols);
}
if (suites != null) {
socket.setEnabledCipherSuites(suites);
}
socket.startHandshake();
// TODO the following setup appears to duplicate that in the super class methods
_socket_ = socket;
_controlInput_ = new BufferedReader(new InputStreamReader(socket.getInputStream(), getControlEncoding()));
_controlOutput_ = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), getControlEncoding()));
if (isClientMode && (hostnameVerifier != null && !hostnameVerifier.verify(_hostname_, socket.getSession()))) {
throw new SSLHandshakeException("Hostname doesn't match certificate");
}
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPSCommand.java 0000664 0000000 0000000 00000003544 14340477222 0031426 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
/**
* FTPS-specific commands.
*
* @since 2.0
* @deprecated 3.0 DO NOT USE
*/
@Deprecated
public final class FTPSCommand {
public static final int AUTH = 0;
public static final int ADAT = 1;
public static final int PBSZ = 2;
public static final int PROT = 3;
public static final int CCC = 4;
public static final int AUTHENTICATION_SECURITY_MECHANISM = AUTH;
public static final int AUTHENTICATION_SECURITY_DATA = ADAT;
public static final int PROTECTION_BUFFER_SIZE = PBSZ;
public static final int DATA_CHANNEL_PROTECTION_LEVEL = PROT;
public static final int CLEAR_COMMAND_CHANNEL = CCC;
private static final String[] commands = { "AUTH", "ADAT", "PBSZ", "PROT", "CCC" };
/**
* Retrieve the FTPS command string corresponding to a specified command code.
*
* @param command The command code.
* @return The FTPS command string corresponding to a specified command code.
*/
public static String getCommand(final int command) {
return commands[command];
}
}
FTPSServerSocketFactory.java 0000664 0000000 0000000 00000005776 14340477222 0033751 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp /*
* 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.ftp;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import javax.net.ServerSocketFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
/**
* Server socket factory for FTPS connections.
*
* @since 2.2
*/
public class FTPSServerSocketFactory extends ServerSocketFactory {
/** Factory for secure socket factories */
private final SSLContext sslContext;
/**
* Constructs a new instance for the given SSL context.
*
* @param sslContext The SSL context.
*/
public FTPSServerSocketFactory(final SSLContext sslContext) {
this.sslContext = sslContext;
}
@SuppressWarnings("resource") // Factory method.
@Override
public ServerSocket createServerSocket() throws IOException {
return init(getServerSocketFactory().createServerSocket());
}
@SuppressWarnings("resource") // Factory method.
@Override
public ServerSocket createServerSocket(final int port) throws IOException {
return init(getServerSocketFactory().createServerSocket(port));
}
@SuppressWarnings("resource") // Factory method.
@Override
public ServerSocket createServerSocket(final int port, final int backlog) throws IOException {
return init(getServerSocketFactory().createServerSocket(port, backlog));
}
@SuppressWarnings("resource") // Factory method.
@Override
public ServerSocket createServerSocket(final int port, final int backlog, final InetAddress ifAddress) throws IOException {
return init(getServerSocketFactory().createServerSocket(port, backlog, ifAddress));
}
private SSLServerSocketFactory getServerSocketFactory() {
return this.sslContext.getServerSocketFactory();
}
/**
* Sets the socket so newly accepted connections will use SSL client mode.
*
* @param socket the SSLServerSocket to initialize
* @return the socket
* @throws ClassCastException if socket is not an instance of SSLServerSocket
*/
public ServerSocket init(final ServerSocket socket) {
((SSLServerSocket) socket).setUseClientMode(true);
return socket;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPSSocketFactory.java 0000664 0000000 0000000 00000010407 14340477222 0032624 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import javax.net.SocketFactory;
import javax.net.ssl.SSLContext;
/**
*
* Socket factory for FTPS connections.
*
* @since 2.0
*/
public class FTPSSocketFactory extends SocketFactory {
private final SSLContext context;
public FTPSSocketFactory(final SSLContext context) {
this.context = context;
}
/**
* @param port the port
* @return the socket
* @throws IOException on error
* @deprecated (2.2) use {@link FTPSServerSocketFactory#createServerSocket(int) instead}
*/
@Deprecated
public java.net.ServerSocket createServerSocket(final int port) throws IOException {
return this.init(this.context.getServerSocketFactory().createServerSocket(port));
}
/**
* @param port the port
* @param backlog the backlog
* @return the socket
* @throws IOException on error
* @deprecated (2.2) use {@link FTPSServerSocketFactory#createServerSocket(int, int) instead}
*/
@Deprecated
public java.net.ServerSocket createServerSocket(final int port, final int backlog) throws IOException {
return this.init(this.context.getServerSocketFactory().createServerSocket(port, backlog));
}
/**
* @param port the port
* @param backlog the backlog
* @param ifAddress the interface
* @return the socket
* @throws IOException on error
* @deprecated (2.2) use {@link FTPSServerSocketFactory#createServerSocket(int, int, InetAddress) instead}
*/
@Deprecated
public java.net.ServerSocket createServerSocket(final int port, final int backlog, final InetAddress ifAddress) throws IOException {
return this.init(this.context.getServerSocketFactory().createServerSocket(port, backlog, ifAddress));
}
// Override the default implementation
@Override
public Socket createSocket() throws IOException {
return this.context.getSocketFactory().createSocket();
}
@Override
public Socket createSocket(final InetAddress address, final int port) throws IOException {
return this.context.getSocketFactory().createSocket(address, port);
}
// DEPRECATED METHODS - for API compatibility only - DO NOT USE
@Override
public Socket createSocket(final InetAddress address, final int port, final InetAddress localAddress, final int localPort) throws IOException {
return this.context.getSocketFactory().createSocket(address, port, localAddress, localPort);
}
@Override
public Socket createSocket(final String address, final int port) throws UnknownHostException, IOException {
return this.context.getSocketFactory().createSocket(address, port);
}
@Override
public Socket createSocket(final String address, final int port, final InetAddress localAddress, final int localPort)
throws UnknownHostException, IOException {
return this.context.getSocketFactory().createSocket(address, port, localAddress, localPort);
}
/**
* @param socket the socket
* @return the socket
* @throws IOException on error
* @deprecated (2.2) use {@link FTPSServerSocketFactory#init(java.net.ServerSocket)}
*/
@Deprecated
public java.net.ServerSocket init(final java.net.ServerSocket socket) throws IOException {
((javax.net.ssl.SSLServerSocket) socket).setUseClientMode(true);
return socket;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/FTPSTrustManager.java 0000664 0000000 0000000 00000003532 14340477222 0032461 0 ustar 00root root 0000000 0000000 /*
* 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.ftp;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.X509TrustManager;
import org.apache.commons.net.util.NetConstants;
/**
* Do not use.
*
* @since 2.0
* @deprecated 3.0 use {@link org.apache.commons.net.util.TrustManagerUtils#getValidateServerCertificateTrustManager()
* TrustManagerUtils#getValidateServerCertificateTrustManager()} instead
*/
@Deprecated
public class FTPSTrustManager implements X509TrustManager {
/**
* No-op
*/
@Override
public void checkClientTrusted(final X509Certificate[] certificates, final String authType) {
}
@Override
public void checkServerTrusted(final X509Certificate[] certificates, final String authType) throws CertificateException {
for (final X509Certificate certificate : certificates) {
certificate.checkValidity();
}
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return NetConstants.EMPTY_X509_CERTIFICATE_ARRAY;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/package-info.java 0000664 0000000 0000000 00000001557 14340477222 0031701 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* FTP and FTPS support classes
*/
package org.apache.commons.net.ftp; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser/ 0000775 0000000 0000000 00000000000 14340477222 0027776 5 ustar 00root root 0000000 0000000 CompositeFileEntryParser.java 0000664 0000000 0000000 00000004273 14340477222 0035531 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPFileEntryParser;
import org.apache.commons.net.ftp.FTPFileEntryParserImpl;
/**
* This implementation allows to pack some FileEntryParsers together and handle the case where to returned dir style isn't clearly defined. The matching parser
* will be cached. If the cached parser wont match due to the server changed the dir style, a new matching parser will be searched.
*/
public class CompositeFileEntryParser extends FTPFileEntryParserImpl {
private final FTPFileEntryParser[] ftpFileEntryParsers;
private FTPFileEntryParser cachedFtpFileEntryParser;
public CompositeFileEntryParser(final FTPFileEntryParser[] ftpFileEntryParsers) {
this.cachedFtpFileEntryParser = null;
this.ftpFileEntryParsers = ftpFileEntryParsers;
}
@Override
public FTPFile parseFTPEntry(final String listEntry) {
if (cachedFtpFileEntryParser != null) {
return cachedFtpFileEntryParser.parseFTPEntry(listEntry);
}
for (final FTPFileEntryParser ftpFileEntryParser : ftpFileEntryParsers) {
final FTPFile matched = ftpFileEntryParser.parseFTPEntry(listEntry);
if (matched != null) {
cachedFtpFileEntryParser = ftpFileEntryParser;
return matched;
}
}
return null;
}
}
ConfigurableFTPFileEntryParserImpl.java 0000664 0000000 0000000 00000011370 14340477222 0037357 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.text.ParseException;
import java.util.Calendar;
import org.apache.commons.net.ftp.Configurable;
import org.apache.commons.net.ftp.FTPClientConfig;
/**
* timestampParser for extracting the timestamp.
* @return a java.util.Calendar containing results of the timestamp parse.
* @throws ParseException on parse error
*/
public Calendar parseTimestamp(final String timestampStr) throws ParseException {
return this.timestampParser.parseTimestamp(timestampStr);
}
}
DefaultFTPFileEntryParserFactory.java 0000664 0000000 0000000 00000026505 14340477222 0037057 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.util.regex.Pattern;
import org.apache.commons.net.ftp.Configurable;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFileEntryParser;
/**
* This is the default implementation of the FTPFileEntryParserFactory interface. This is the implementation that will be used by
* org.apache.commons.net.ftp.FTPClient.listFiles() if no other implementation has been specified.
*
* @see org.apache.commons.net.ftp.FTPClient#listFiles
* @see org.apache.commons.net.ftp.FTPClient#setParserFactory
*/
public class DefaultFTPFileEntryParserFactory implements FTPFileEntryParserFactory {
// Match a plain Java Identifier
private static final String JAVA_IDENTIFIER = "\\p{javaJavaIdentifierStart}(\\p{javaJavaIdentifierPart})*";
// Match a qualified name, e.g. a.b.c.Name - but don't allow the default package as that would allow "VMS"/"UNIX" etc.
private static final String JAVA_QUALIFIED_NAME = "(" + JAVA_IDENTIFIER + "\\.)+" + JAVA_IDENTIFIER;
// Create the pattern, as it will be reused many times
private static final Pattern JAVA_QUALIFIED_NAME_PATTERN = Pattern.compile(JAVA_QUALIFIED_NAME);
/**
* key is not recognized as a fully qualified classname known to the system, this method will then attempt to see whether it contains
* a string identifying one of the known parsers. This comparison is case-insensitive. The intent here is where possible, to select as keys strings
* which are returned by the SYST command on the systems which the corresponding parser successfully parses. This enables this factory to be used in the
* auto-detection system.
*
* @param key should be a fully qualified classname corresponding to a class implementing the FTPFileEntryParser interface
* OR
* a string containing (case-insensitively) one of the following keywords:
*
*
* @return the FTPFileEntryParser corresponding to the supplied key.
* @throws ParserInitializationException thrown if for any reason the factory cannot resolve the supplied key into an FTPFileEntryParser.
* @see FTPFileEntryParser
*/
@Override
public FTPFileEntryParser createFileEntryParser(final String key) {
if (key == null) {
throw new ParserInitializationException("Parser key cannot be null");
}
return createFileEntryParser(key, null);
}
// Common method to process both key and config parameters.
private FTPFileEntryParser createFileEntryParser(final String key, final FTPClientConfig config) {
FTPFileEntryParser parser = null;
// Is the key a possible class name?
if (JAVA_QUALIFIED_NAME_PATTERN.matcher(key).matches()) {
try {
final Class parserClass = Class.forName(key);
try {
parser = (FTPFileEntryParser) parserClass.newInstance();
} catch (final ClassCastException e) {
throw new ParserInitializationException(
parserClass.getName() + " does not implement the interface " + "org.apache.commons.net.ftp.FTPFileEntryParser.", e);
} catch (final Exception | ExceptionInInitializerError e) {
throw new ParserInitializationException("Error initializing parser", e);
}
} catch (final ClassNotFoundException e) {
// OK, assume it is an alias
}
}
if (parser == null) { // Now try for aliases
final String ukey = key.toUpperCase(java.util.Locale.ENGLISH);
if (ukey.contains(FTPClientConfig.SYST_UNIX_TRIM_LEADING)) {
parser = new UnixFTPEntryParser(config, true);
}
// must check this after SYST_UNIX_TRIM_LEADING as it is a substring of it
else if (ukey.contains(FTPClientConfig.SYST_UNIX)) {
parser = new UnixFTPEntryParser(config, false);
} else if (ukey.contains(FTPClientConfig.SYST_VMS)) {
parser = new VMSVersioningFTPEntryParser(config);
} else if (ukey.contains(FTPClientConfig.SYST_NT)) {
parser = createNTFTPEntryParser(config);
} else if (ukey.contains(FTPClientConfig.SYST_OS2)) {
parser = new OS2FTPEntryParser(config);
} else if (ukey.contains(FTPClientConfig.SYST_OS400) || ukey.contains(FTPClientConfig.SYST_AS400)) {
parser = createOS400FTPEntryParser(config);
} else if (ukey.contains(FTPClientConfig.SYST_MVS)) {
parser = new MVSFTPEntryParser(); // Does not currently support config parameter
} else if (ukey.contains(FTPClientConfig.SYST_NETWARE)) {
parser = new NetwareFTPEntryParser(config);
} else if (ukey.contains(FTPClientConfig.SYST_MACOS_PETER)) {
parser = new MacOsPeterFTPEntryParser(config);
} else if (ukey.contains(FTPClientConfig.SYST_L8)) {
// L8 normally means Unix, but move it to the end for some L8 systems that aren't.
// This check should be last!
parser = new UnixFTPEntryParser(config);
} else {
throw new ParserInitializationException("Unknown parser type: " + key);
}
}
if (parser instanceof Configurable) {
((Configurable) parser).configure(config);
}
return parser;
}
public FTPFileEntryParser createMVSEntryParser() {
return new MVSFTPEntryParser();
}
public FTPFileEntryParser createNetwareFTPEntryParser() {
return new NetwareFTPEntryParser();
}
public FTPFileEntryParser createNTFTPEntryParser() {
return createNTFTPEntryParser(null);
}
/**
* Creates an NT FTP parser: if the config exists, and the system key equals {@link FTPClientConfig#SYST_NT} then a plain {@link NTFTPEntryParser} is used,
* otherwise a composite of {@link NTFTPEntryParser} and {@link UnixFTPEntryParser} is used.
*
* @param config the config to use, may be {@code null}
* @return the parser
*/
private FTPFileEntryParser createNTFTPEntryParser(final FTPClientConfig config) {
if (config != null && FTPClientConfig.SYST_NT.equals(config.getServerSystemKey())) {
return new NTFTPEntryParser(config);
}
// clone the config as it may be changed by the parsers (NET-602)
final FTPClientConfig config2 = config != null ? new FTPClientConfig(config) : null;
return new CompositeFileEntryParser(new FTPFileEntryParser[] { new NTFTPEntryParser(config),
new UnixFTPEntryParser(config2, config2 != null && FTPClientConfig.SYST_UNIX_TRIM_LEADING.equals(config2.getServerSystemKey())) });
}
public FTPFileEntryParser createOS2FTPEntryParser() {
return new OS2FTPEntryParser();
}
public FTPFileEntryParser createOS400FTPEntryParser() {
return createOS400FTPEntryParser(null);
}
/**
* Creates an OS400 FTP parser: if the config exists, and the system key equals {@link FTPClientConfig#SYST_OS400} then a plain {@link OS400FTPEntryParser}
* is used, otherwise a composite of {@link OS400FTPEntryParser} and {@link UnixFTPEntryParser} is used.
*
* @param config the config to use, may be {@code null}
* @return the parser
*/
private FTPFileEntryParser createOS400FTPEntryParser(final FTPClientConfig config) {
if (config != null && FTPClientConfig.SYST_OS400.equals(config.getServerSystemKey())) {
return new OS400FTPEntryParser(config);
}
// clone the config as it may be changed by the parsers (NET-602)
final FTPClientConfig config2 = config != null ? new FTPClientConfig(config) : null;
return new CompositeFileEntryParser(new FTPFileEntryParser[] { new OS400FTPEntryParser(config),
new UnixFTPEntryParser(config2, config2 != null && FTPClientConfig.SYST_UNIX_TRIM_LEADING.equals(config2.getServerSystemKey())) });
}
public FTPFileEntryParser createUnixFTPEntryParser() {
return new UnixFTPEntryParser();
}
public FTPFileEntryParser createVMSVersioningFTPEntryParser() {
return new VMSVersioningFTPEntryParser();
}
}
EnterpriseUnixFTPEntryParser.java 0000664 0000000 0000000 00000013516 14340477222 0036325 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.util.Calendar;
import org.apache.commons.net.ftp.FTPFile;
/**
* Parser for the Connect Enterprise Unix FTP Server From Sterling Commerce. Here is a sample of the sort of output line this parser processes:
*
*
* "-C--E-----FTP B QUA1I1 18128 41 Aug 12 13:56 QUADTEST"
*
* FTPFile instance. If the file
* listing line doesn't describe a file, null is returned, otherwise a FTPFile instance representing the files in the
* directory is returned.
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
final FTPFile file = new FTPFile();
file.setRawListing(entry);
if (matches(entry)) {
final String usr = group(14);
final String grp = group(15);
final String filesize = group(16);
final String mo = group(17);
final String da = group(18);
final String yr = group(20);
final String hr = group(21);
final String min = group(22);
final String name = group(23);
file.setType(FTPFile.FILE_TYPE);
file.setUser(usr);
file.setGroup(grp);
try {
file.setSize(Long.parseLong(filesize));
} catch (final NumberFormatException e) {
// intentionally do nothing
}
final Calendar cal = Calendar.getInstance();
cal.set(Calendar.MILLISECOND, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.HOUR_OF_DAY, 0);
final int pos = MONTHS.indexOf(mo);
final int month = pos / 4;
final int missingUnit; // the first missing unit
try {
if (yr != null) {
// it's a year; there are no hours and minutes
cal.set(Calendar.YEAR, Integer.parseInt(yr));
missingUnit = Calendar.HOUR_OF_DAY;
} else {
// it must be hour/minute or we wouldn't have matched
missingUnit = Calendar.SECOND;
int year = cal.get(Calendar.YEAR);
// if the month we're reading is greater than now, it must
// be last year
if (cal.get(Calendar.MONTH) < month) {
year--;
}
cal.set(Calendar.YEAR, year);
cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hr));
cal.set(Calendar.MINUTE, Integer.parseInt(min));
}
cal.set(Calendar.MONTH, month);
cal.set(Calendar.DAY_OF_MONTH, Integer.parseInt(da));
cal.clear(missingUnit);
file.setTimestamp(cal);
} catch (final NumberFormatException e) {
// do nothing, date will be uninitialized
}
file.setName(name);
return file;
}
return null;
}
}
FTPFileEntryParserFactory.java 0000664 0000000 0000000 00000005001 14340477222 0035536 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFileEntryParser;
/**
* The interface describes a factory for creating FTPFileEntryParsers.
*
* @since 1.2
*/
public interface FTPFileEntryParserFactory {
/**
* java.util.Calendar object initialized to the date parsed by the parser
* @throws ParseException if none of the parser mechanisms belonging to the implementor can parse the input.
*/
Calendar parseTimestamp(String timestampStr) throws ParseException;
}
FTPTimestampParserImpl.java 0000664 0000000 0000000 00000037547 14340477222 0035116 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.text.DateFormatSymbols;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import org.apache.commons.net.ftp.Configurable;
import org.apache.commons.net.ftp.FTPClientConfig;
/**
* Default implementation of the {@link FTPTimestampParser FTPTimestampParser} interface also implements the {@link org.apache.commons.net.ftp.Configurable
* Configurable} interface to allow the parsing to be configured from the outside.
*
* @see ConfigurableFTPFileEntryParserImpl
* @since 1.4
*/
public class FTPTimestampParserImpl implements FTPTimestampParser, Configurable {
/*
* List of units in order of increasing significance. This allows the code to clear all units in the Calendar until it reaches the least significant unit in
* the parse string. The date formats are analysed to find the least significant unit (e.g. Minutes or Milliseconds) and the appropriate index to the array
* is saved. This is done by searching the array for the unit specifier, and returning the index. When clearing the Calendar units, the code loops through
* the array until the previous entry. e.g. for MINUTE it would clear MILLISECOND and SECOND
*/
private static final int[] CALENDAR_UNITS = { Calendar.MILLISECOND, Calendar.SECOND, Calendar.MINUTE, Calendar.HOUR_OF_DAY, Calendar.DAY_OF_MONTH,
Calendar.MONTH, Calendar.YEAR };
/*
* Return the index to the array representing the least significant unit found in the date format. Default is 0 (to avoid dropping precision)
*/
private static int getEntry(final SimpleDateFormat dateFormat) {
if (dateFormat == null) {
return 0;
}
final String FORMAT_CHARS = "SsmHdM";
final String pattern = dateFormat.toPattern();
for (final char ch : FORMAT_CHARS.toCharArray()) {
if (pattern.indexOf(ch) != -1) { // found the character
switch (ch) {
case 'S':
return indexOf(Calendar.MILLISECOND);
case 's':
return indexOf(Calendar.SECOND);
case 'm':
return indexOf(Calendar.MINUTE);
case 'H':
return indexOf(Calendar.HOUR_OF_DAY);
case 'd':
return indexOf(Calendar.DAY_OF_MONTH);
case 'M':
return indexOf(Calendar.MONTH);
}
}
}
return 0;
}
/*
* Find the entry in the CALENDAR_UNITS array.
*/
private static int indexOf(final int calendarUnit) {
int i;
for (i = 0; i < CALENDAR_UNITS.length; i++) {
if (calendarUnit == CALENDAR_UNITS[i]) {
return i;
}
}
return 0;
}
/*
* Sets the Calendar precision (used by FTPFile#toFormattedDate) by clearing the immediately preceeding unit (if any). Unfortunately the clear(int) method
* results in setting all other units.
*/
private static void setPrecision(final int index, final Calendar working) {
if (index <= 0) { // e.g. MILLISECONDS
return;
}
final int field = CALENDAR_UNITS[index - 1];
// Just in case the analysis is wrong, stop clearing if
// field value is not the default.
final int value = working.get(field);
if (value != 0) { // don't reset if it has a value
// new Throwable("Unexpected value "+value).printStackTrace(); // DEBUG
} else {
working.clear(field); // reset just the required field
}
}
/** The date format for all dates, except possibly recent dates. Assumed to include the year. */
private SimpleDateFormat defaultDateFormat;
/* The index in CALENDAR_UNITS of the smallest time unit in defaultDateFormat */
private int defaultDateSmallestUnitIndex;
/** The format used for recent dates (which don't have the year). May be null. */
private SimpleDateFormat recentDateFormat;
/* The index in CALENDAR_UNITS of the smallest time unit in recentDateFormat */
private int recentDateSmallestUnitIndex;
private boolean lenientFutureDates;
/**
* The only constructor for this class.
*/
public FTPTimestampParserImpl() {
setDefaultDateFormat(DEFAULT_SDF, null);
setRecentDateFormat(DEFAULT_RECENT_SDF, null);
}
/**
* Implementation of the {@link Configurable Configurable} interface. Configures this FTPTimestampParser according to the following logic:
*
*
* config, use that to parse parse
* timestamps.config, use the month
* names represented by that {@link FTPClientConfig#lookupDateFormatSymbols(String) language} to parse timestamps.
* entry = [ facts ] SP pathname
* facts = 1*( fact ";" )
* fact = factname "=" value
* factname = "Size" / "Modify" / "Create" /
* "Type" / "Unique" / "Perm" /
* "Lang" / "Media-Type" / "CharSet" /
* os-depend-fact / local-fact
* os-depend-fact = {IANA assigned OS name} "." token
* local-fact = "X." token
* value = *SCHAR
*
* Sample os-depend-fact:
* UNIX.group=0;UNIX.mode=0755;UNIX.owner=0;
*
*
* Volume Unit Referred Ext Used Recfm Lrecl BlkSz Dsorg Dsname
* B10142 3390 2006/03/20 2 31 F 80 80 PS MDI.OKL.WORK
*
*
* @see Data set record formats
*/
static final String FILE_LIST_REGEX = "\\S+\\s+" + // volume
// ignored
"\\S+\\s+" + // unit - ignored
"\\S+\\s+" + // access date - ignored
"\\S+\\s+" + // extents -ignored
// If the values are too large, the fields may be merged (NET-639)
"(?:\\S+\\s+)?" + // used - ignored
"(?:F|FB|V|VB|U)\\s+" + // recfm - F[B], V[B], U
"\\S+\\s+" + // logical record length -ignored
"\\S+\\s+" + // block size - ignored
"(PS|PO|PO-E)\\s+" + // Dataset organisation. Many exist
// but only support: PS, PO, PO-E
"(\\S+)\\s*"; // Dataset Name (file name)
/**
* Matches these entries:
*
*
* Name VV.MM Created Changed Size Init Mod Id
* TBSHELF 01.03 2002/09/12 2002/10/11 09:37 11 11 0 KIL001
*
*/
static final String MEMBER_LIST_REGEX = "(\\S+)\\s+" + // name
"\\S+\\s+" + // version, modification (ignored)
"\\S+\\s+" + // create date (ignored)
"(\\S+)\\s+" + // modification date
"(\\S+)\\s+" + // modification time
"\\S+\\s+" + // size in lines (ignored)
"\\S+\\s+" + // size in lines at creation(ignored)
"\\S+\\s+" + // lines modified (ignored)
"\\S+\\s*"; // id of user who modified (ignored)
/**
* Matches these entries, note: no header:
*
*
* IBMUSER1 JOB01906 OUTPUT 3 Spool Files
* 012345678901234567890123456789012345678901234
* 1 2 3 4
*
*/
static final String JES_LEVEL_1_LIST_REGEX = "(\\S+)\\s+" + // job name ignored
"(\\S+)\\s+" + // job number
"(\\S+)\\s+" + // job status (OUTPUT,INPUT,ACTIVE)
"(\\S+)\\s+" + // number of spool files
"(\\S+)\\s+" + // Text "Spool" ignored
"(\\S+)\\s*" // Text "Files" ignored
;
/**
* JES INTERFACE LEVEL 2 parser Matches these entries:
*
*
* JOBNAME JOBID OWNER STATUS CLASS
* IBMUSER1 JOB01906 IBMUSER OUTPUT A RC=0000 3 spool files
* IBMUSER TSU01830 IBMUSER OUTPUT TSU ABEND=522 3 spool files
*
*
* Sample output from FTP session:
*
*
* ftp> quote site filetype=jes
* 200 SITE command was accepted
* ftp> ls
* 200 Port request OK.
* 125 List started OK for JESJOBNAME=IBMUSER*, JESSTATUS=ALL and JESOWNER=IBMUSER
* JOBNAME JOBID OWNER STATUS CLASS
* IBMUSER1 JOB01906 IBMUSER OUTPUT A RC=0000 3 spool files
* IBMUSER TSU01830 IBMUSER OUTPUT TSU ABEND=522 3 spool files
* 250 List completed successfully.
* ftp> ls job01906
* 200 Port request OK.
* 125 List started OK for JESJOBNAME=IBMUSER*, JESSTATUS=ALL and JESOWNER=IBMUSER
* JOBNAME JOBID OWNER STATUS CLASS
* IBMUSER1 JOB01906 IBMUSER OUTPUT A RC=0000
* --------
* ID STEPNAME PROCSTEP C DDNAME BYTE-COUNT
* 001 JES2 A JESMSGLG 858
* 002 JES2 A JESJCL 128
* 003 JES2 A JESYSMSG 443
* 3 spool files
* 250 List completed successfully.
*
*/
static final String JES_LEVEL_2_LIST_REGEX = "(\\S+)\\s+" + // job name ignored
"(\\S+)\\s+" + // job number
"(\\S+)\\s+" + // owner ignored
"(\\S+)\\s+" + // job status (OUTPUT,INPUT,ACTIVE) ignored
"(\\S+)\\s+" + // job class ignored
"(\\S+).*" // rest ignored
;
private int isType = UNKNOWN_LIST_TYPE;
/**
* Fallback parser for Unix-style listings
*/
private UnixFTPEntryParser unixFTPEntryParser;
/*
* --------------------------------------------------------------------- Very brief and incomplete description of the zOS/MVS-file system. (Note: "zOS" is
* the operating system on the mainframe, and is the new name for MVS)
*
* The file system on the mainframe does not have hierarchal structure as for example the unix file system. For a more comprehensive description, please
* refer to the IBM manuals
*
* @LINK: http://publibfp.boulder.ibm.com/cgi-bin/bookmgr/BOOKS/dgt2d440/CONTENTS
*
*
* Dataset names =============
*
* A dataset name consist of a number of qualifiers separated by '.', each qualifier can be at most 8 characters, and the total length of a dataset can be
* max 44 characters including the dots.
*
*
* Dataset organisation ====================
*
* A dataset represents a piece of storage allocated on one or more disks. The structure of the storage is described with the field dataset organinsation
* (DSORG). There are a number of dataset organisations, but only two are usable for FTP transfer.
*
* DSORG: PS: sequential, or flat file PO: partitioned dataset PO-E: extended partitioned dataset
*
* The PS file is just a flat file, as you would find it on the unix file system.
*
* The PO and PO-E files, can be compared to a single level directory structure. A PO file consist of a number of dataset members, or files if you will. It
* is possible to CD into the file, and to retrieve the individual members.
*
*
* Dataset record format =====================
*
* The physical layout of the dataset is described on the dataset itself. There are a number of record formats (RECFM), but just a few is relavant for the
* FTP transfer.
*
* Any one beginning with either F or V can safely used by FTP transfer. All others should only be used with great care. F means a fixed number of records
* per allocated storage, and V means a variable number of records.
*
*
* Other notes ===========
*
* The file system supports automatically backup and retrieval of datasets. If a file is backed up, the ftp LIST command will return: ARCIVE Not Direct
* Access Device KJ.IOP998.ERROR.PL.UNITTEST
*
*
* Implementation notes ====================
*
* Only datasets that have dsorg PS, PO or PO-E and have recfm beginning with F or V or U, is fully parsed.
*
* The following fields in FTPFile is used: FTPFile.Rawlisting: Always set. FTPFile.Type: DIRECTORY_TYPE or FILE_TYPE or UNKNOWN FTPFile.Name: name
* FTPFile.Timestamp: change time or null
*
*
*
* Additional information ======================
*
* The MVS ftp server supports a number of features via the FTP interface. The features are controlled with the FTP command quote site
* filetype= FTPFile instance. If the
* file listing line doesn't describe a file, then null is returned. Otherwise a FTPFile instance representing the file is
* returned.
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
switch (isType) {
case FILE_LIST_TYPE:
return parseFileList(entry);
case MEMBER_LIST_TYPE:
return parseMemberList(entry);
case UNIX_LIST_TYPE:
return unixFTPEntryParser.parseFTPEntry(entry);
case JES_LEVEL_1_LIST_TYPE:
return parseJeslevel1List(entry);
case JES_LEVEL_2_LIST_TYPE:
return parseJeslevel2List(entry);
default:
break;
}
return null;
}
/**
* Matches these entries, note: no header:
*
*
* [1] [2] [3] [4] [5]
* IBMUSER1 JOB01906 OUTPUT 3 Spool Files
* 012345678901234567890123456789012345678901234
* 1 2 3 4
* -------------------------------------------
* Group in regex
* [1] Job name
* [2] Job number
* [3] Job status (INPUT,ACTIVE,OUTPUT)
* [4] Number of sysout files
* [5] The string "Spool Files"
*
*
* @param entry zosDirectoryEntry
* @return null: entry was not parsed.
*/
private FTPFile parseJeslevel1List(final String entry) {
if (matches(entry)) {
final FTPFile file = new FTPFile();
if (group(3).equalsIgnoreCase("OUTPUT")) {
file.setRawListing(entry);
final String name = group(2); /* Job Number, used by GET */
file.setName(name);
file.setType(FTPFile.FILE_TYPE);
return file;
}
}
return null;
}
/**
* Matches these entries:
*
*
* [1] [2] [3] [4] [5]
* JOBNAME JOBID OWNER STATUS CLASS
* IBMUSER1 JOB01906 IBMUSER OUTPUT A RC=0000 3 spool files
* IBMUSER TSU01830 IBMUSER OUTPUT TSU ABEND=522 3 spool files
* 012345678901234567890123456789012345678901234
* 1 2 3 4
* -------------------------------------------
* Group in regex
* [1] Job name
* [2] Job number
* [3] Owner
* [4] Job status (INPUT,ACTIVE,OUTPUT)
* [5] Job Class
* [6] The rest
*
*
* @param entry zosDirectoryEntry
* @return null: entry was not parsed.
*/
private FTPFile parseJeslevel2List(final String entry) {
if (matches(entry)) {
final FTPFile file = new FTPFile();
if (group(4).equalsIgnoreCase("OUTPUT")) {
file.setRawListing(entry);
final String name = group(2); /* Job Number, used by GET */
file.setName(name);
file.setType(FTPFile.FILE_TYPE);
return file;
}
}
return null;
}
/**
* Parse entries within a partitioned dataset.
*
* Format of a memberlist within a PDS:
*
*
* 0 1 2 3 4 5 6 7 8
* Name VV.MM Created Changed Size Init Mod Id
* TBSHELF 01.03 2002/09/12 2002/10/11 09:37 11 11 0 KIL001
* TBTOOL 01.12 2002/09/12 2004/11/26 19:54 51 28 0 KIL001
*
* -------------------------------------------
* [1] Name
* [2] VV.MM: Version . modification
* [3] Created: yyyy / MM / dd
* [4,5] Changed: yyyy / MM / dd HH:mm
* [6] Size: number of lines
* [7] Init: number of lines when first created
* [8] Mod: number of modified lines a last save
* [9] Id: User id for last update
*
*
* @param entry zosDirectoryEntry
* @return null: entry was not parsed.
*/
private FTPFile parseMemberList(final String entry) {
final FTPFile file = new FTPFile();
if (matches(entry)) {
file.setRawListing(entry);
final String name = group(1);
final String datestr = group(2) + " " + group(3);
file.setName(name);
file.setType(FTPFile.FILE_TYPE);
try {
file.setTimestamp(super.parseTimestamp(datestr));
} catch (final ParseException e) {
// just ignore parsing errors.
// TODO check this is ok
// Drop thru to try simple parser
}
return file;
}
/*
* Assigns the name to the first word of the entry. Only to be used from a safe context, for example from a memberlist, where the regex for some reason
* fails. Then just assign the name field of FTPFile.
*/
if (entry != null && !entry.trim().isEmpty()) {
file.setRawListing(entry);
final String name = entry.split(" ")[0];
file.setName(name);
file.setType(FTPFile.FILE_TYPE);
return file;
}
return null;
}
/**
* preParse is called as part of the interface. Per definition is is called before the parsing takes place. Three kind of lists is recognize: z/OS-MVS File
* lists z/OS-MVS Member lists unix file lists
*
* @since 2.0
*/
@Override
public ListREGEX is not a valid regular expression.
*/
public MacOsPeterFTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of a UnixFTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public MacOsPeterFTPEntryParser(final FTPClientConfig config) {
super(REGEX);
configure(config);
}
/**
* Defines a default configuration to be used when this class is instantiated without a {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for this parser.
*/
@Override
protected FTPClientConfig getDefaultConfiguration() {
return new FTPClientConfig(FTPClientConfig.SYST_UNIX, DEFAULT_DATE_FORMAT, DEFAULT_RECENT_DATE_FORMAT);
}
/**
* Parses a line of a unix (standard) FTP server file listing and converts it into a usable format in the form of an FTPFile instance. If the
* file listing line doesn't describe a file, null is returned, otherwise a FTPFile instance representing the files in the
* directory is returned.
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
final FTPFile file = new FTPFile();
file.setRawListing(entry);
final int type;
boolean isDevice = false;
if (matches(entry)) {
final String typeStr = group(1);
final String hardLinkCount = "0";
final String filesize = group(20);
final String datestr = group(21) + " " + group(22);
String name = group(23);
final String endtoken = group(24);
try {
file.setTimestamp(super.parseTimestamp(datestr));
} catch (final ParseException e) {
// intentionally do nothing
}
// A 'whiteout' file is an ARTIFICIAL entry in any of several types of
// 'translucent' filesystems, of which a 'union' filesystem is one.
// bcdelfmpSs-
switch (typeStr.charAt(0)) {
case 'd':
type = FTPFile.DIRECTORY_TYPE;
break;
case 'e': // NET-39 => z/OS external link
type = FTPFile.SYMBOLIC_LINK_TYPE;
break;
case 'l':
type = FTPFile.SYMBOLIC_LINK_TYPE;
break;
case 'b':
case 'c':
isDevice = true;
type = FTPFile.FILE_TYPE; // TODO change this if DEVICE_TYPE implemented
break;
case 'f':
case '-':
type = FTPFile.FILE_TYPE;
break;
default: // e.g. ? and w = whiteout
type = FTPFile.UNKNOWN_TYPE;
}
file.setType(type);
int g = 4;
for (int access = 0; access < 3; access++, g += 4) {
// Use != '-' to avoid having to check for suid and sticky bits
file.setPermission(access, FTPFile.READ_PERMISSION, (!group(g).equals("-")));
file.setPermission(access, FTPFile.WRITE_PERMISSION, (!group(g + 1).equals("-")));
final String execPerm = group(g + 2);
file.setPermission(access, FTPFile.EXECUTE_PERMISSION, !execPerm.equals("-") && !Character.isUpperCase(execPerm.charAt(0)));
}
if (!isDevice) {
try {
file.setHardLinkCount(Integer.parseInt(hardLinkCount));
} catch (final NumberFormatException e) {
// intentionally do nothing
}
}
file.setUser(null);
file.setGroup(null);
try {
file.setSize(Long.parseLong(filesize));
} catch (final NumberFormatException e) {
// intentionally do nothing
}
if (null == endtoken) {
file.setName(name);
} else {
// oddball cases like symbolic links, file names
// with spaces in them.
name += endtoken;
if (type == FTPFile.SYMBOLIC_LINK_TYPE) {
final int end = name.indexOf(" -> ");
// Give up if no link indicator is present
if (end == -1) {
file.setName(name);
} else {
file.setName(name.substring(0, end));
file.setLink(name.substring(end + 4));
}
} else {
file.setName(name);
}
}
return file;
}
return null;
}
}
NTFTPEntryParser.java 0000664 0000000 0000000 00000012563 14340477222 0033663 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.text.ParseException;
import java.util.regex.Pattern;
import org.apache.commons.net.ftp.Configurable;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
/**
* Implementation of FTPFileEntryParser and FTPFileListParser for NT Systems.
*
* @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)
*/
public class NTFTPEntryParser extends ConfigurableFTPFileEntryParserImpl {
private static final String DEFAULT_DATE_FORMAT = "MM-dd-yy hh:mma"; // 11-09-01 12:30PM
private static final String DEFAULT_DATE_FORMAT2 = "MM-dd-yy kk:mm"; // 11-09-01 18:30
/**
* this is the regular expression used by this parser.
*/
private static final String REGEX = "(\\S+)\\s+(\\S+)\\s+" // MM-dd-yy whitespace hh:mma|kk:mm; swallow trailing spaces
+ "(?:(REGEX is not a valid regular expression.
*/
public NTFTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of an NTFTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public NTFTPEntryParser(final FTPClientConfig config) {
super(REGEX, Pattern.DOTALL);
configure(config);
final FTPClientConfig config2 = new FTPClientConfig(FTPClientConfig.SYST_NT, DEFAULT_DATE_FORMAT2, null);
config2.setDefaultDateFormatStr(DEFAULT_DATE_FORMAT2);
this.timestampParser = new FTPTimestampParserImpl();
((Configurable) this.timestampParser).configure(config2);
}
/**
* Defines a default configuration to be used when this class is instantiated without a {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for this parser.
*/
@Override
public FTPClientConfig getDefaultConfiguration() {
return new FTPClientConfig(FTPClientConfig.SYST_NT, DEFAULT_DATE_FORMAT, null);
}
/**
* Parses a line of an NT FTP server file listing and converts it into a usable format in the form of an FTPFile instance. If the file
* listing line doesn't describe a file, null is returned, otherwise a FTPFile instance representing the files in the
* directory is returned.
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
final FTPFile f = new FTPFile();
f.setRawListing(entry);
if (matches(entry)) {
final String datestr = group(1) + " " + group(2);
final String dirString = group(3);
final String size = group(4);
final String name = group(5);
try {
f.setTimestamp(super.parseTimestamp(datestr));
} catch (final ParseException e) {
// parsing fails, try the other date format
try {
f.setTimestamp(timestampParser.parseTimestamp(datestr));
} catch (final ParseException e2) {
// intentionally do nothing
}
}
if (null == name || name.equals(".") || name.equals("..")) {
return null;
}
f.setName(name);
if ("REGEX is not a valid regular expression.
*/
public NetwareFTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of an NetwareFTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public NetwareFTPEntryParser(final FTPClientConfig config) {
super(REGEX);
configure(config);
}
/**
* Defines a default configuration to be used when this class is instantiated without a {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for this parser.
*/
@Override
protected FTPClientConfig getDefaultConfiguration() {
return new FTPClientConfig(FTPClientConfig.SYST_NETWARE, DEFAULT_DATE_FORMAT, DEFAULT_RECENT_DATE_FORMAT);
}
/**
* Parses a line of an NetwareFTP server file listing and converts it into a usable format in the form of an FTPFile instance. If the file
* listing line doesn't describe a file, null is returned, otherwise a FTPFile instance representing the files in the
* directory is returned.
*
*
*
* See here for more details
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
final FTPFile f = new FTPFile();
if (matches(entry)) {
final String dirString = group(1);
final String attrib = group(2);
final String user = group(3);
final String size = group(4);
final String datestr = group(5);
final String name = group(9);
try {
f.setTimestamp(super.parseTimestamp(datestr));
} catch (final ParseException e) {
// intentionally do nothing
}
// is it a DIR or a file
if (dirString.trim().equals("d")) {
f.setType(FTPFile.DIRECTORY_TYPE);
} else // Should be "-"
{
f.setType(FTPFile.FILE_TYPE);
}
f.setUser(user);
// set the name
f.setName(name.trim());
// set the size
f.setSize(Long.parseLong(size.trim()));
// Now set the permissions (or at least a subset thereof - full permissions would probably require
// subclassing FTPFile and adding extra metainformation there)
if (attrib.indexOf('R') != -1) {
f.setPermission(FTPFile.USER_ACCESS, FTPFile.READ_PERMISSION, true);
}
if (attrib.indexOf('W') != -1) {
f.setPermission(FTPFile.USER_ACCESS, FTPFile.WRITE_PERMISSION, true);
}
return f;
}
return null;
}
}
OS2FTPEntryParser.java 0000664 0000000 0000000 00000010712 14340477222 0033737 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.text.ParseException;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
/**
* Implementation of FTPFileEntryParser and FTPFileListParser for OS2 Systems.
*
* @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)
*/
public class OS2FTPEntryParser extends ConfigurableFTPFileEntryParserImpl
{
private static final String DEFAULT_DATE_FORMAT = "MM-dd-yy HH:mm"; // 11-09-01 12:30
/**
* this is the regular expression used by this parser.
*/
private static final String REGEX = "\\s*([0-9]+)\\s*" + "(\\s+|[A-Z]+)\\s*" + "(DIR|\\s+)\\s*" + "(\\S+)\\s+(\\S+)\\s+" /* date stuff */
+ "(\\S.*)";
/**
* The default constructor for a OS2FTPEntryParser object.
*
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
*/
public OS2FTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of an OS2FTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public OS2FTPEntryParser(final FTPClientConfig config) {
super(REGEX);
configure(config);
}
/**
* Defines a default configuration to be used when this class is instantiated without a {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for this parser.
*/
@Override
protected FTPClientConfig getDefaultConfiguration() {
return new FTPClientConfig(FTPClientConfig.SYST_OS2, DEFAULT_DATE_FORMAT, null);
}
/**
* Parses a line of an OS2 FTP server file listing and converts it into a usable format in the form of an FTPFile instance. If the file
* listing line doesn't describe a file, null is returned, otherwise a FTPFile instance representing the files in the
* directory is returned.
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
final FTPFile f = new FTPFile();
if (matches(entry)) {
final String size = group(1);
final String attrib = group(2);
final String dirString = group(3);
final String datestr = group(4) + " " + group(5);
final String name = group(6);
try {
f.setTimestamp(super.parseTimestamp(datestr));
} catch (final ParseException e) {
// intentionally do nothing
}
// is it a DIR or a file
if (dirString.trim().equals("DIR") || attrib.trim().equals("DIR")) {
f.setType(FTPFile.DIRECTORY_TYPE);
} else {
f.setType(FTPFile.FILE_TYPE);
}
// set the name
f.setName(name.trim());
// set the size
f.setSize(Long.parseLong(size.trim()));
return f;
}
return null;
}
}
OS400FTPEntryParser.java 0000664 0000000 0000000 00000034236 14340477222 0034110 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.io.File;
import java.text.ParseException;
import java.util.Locale;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
/**
*
* Example *FILE/*MEM FTP entries, when the current
* working directory is a file of file system QSYS:
* ------------------------------------------------
*
* $ cwd /qsys.lib/rpgunit.lib/rpgunitc1.file
* 250-NAMEFMT set to 1.
* 250 "/QSYS.LIB/RPGUNIT.LIB/RPGUNITC1.FILE" is current directory.
* $ dir
* 227 Entering Passive Mode (10,200,36,33,40,249).
* 125 List started.
* QPGMR 135168 22.06.13 13:18:19 *FILE
* QPGMR *MEM MKCMD.MBR
* QPGMR *MEM RUCALLTST.MBR
* QPGMR *MEM RUCMDHLP.MBR
* QPGMR *MEM RUCRTTST.MBR
* 250 List completed.
*
*
* Example *FILE entry of an OS/400 save file:
* ---------------------------------------------------
*
* $ cwd /qsys.lib/rpgunit.lib
* 250 "/QSYS.LIB/RPGUNIT.LIB" is current library.
* $ dir rpgunit.file
* 227 Entering Passive Mode (10,200,36,33,188,106).
* 125 List started.
* QPGMR 16347136 29.06.13 15:45:09 *FILE RPGUNIT.SAVF
* 250 List completed.
*
*
* Example *STMF/*DIR FTP entries, when the
* current working directory is in file system "root":
* ---------------------------------------------------
*
* $ cwd /home/raddatz
* 250 "/home/raddatz" is current directory.
* $ dir test*
* 227 Entering Passive Mode (10,200,36,33,200,189).
* 125 List started.
* RADDATZ 200 21.05.11 12:31:18 *STMF TEST_RG_02_CRLF.properties
* RADDATZ 187 08.05.11 12:31:40 *STMF TEST_RG_02_LF.properties
* RADDATZ 187 08.05.11 12:31:52 *STMF TEST_RG_02_CR.properties
* RADDATZ 8192 04.07.13 09:04:14 *DIR testDir1/
* RADDATZ 8192 04.07.13 09:04:17 *DIR testDir2/
* 250 List completed.
*
*
* Example 1, using ANT to list specific members of a file:
* --------------------------------------------------------
*
* <echo/>
* <echo>Listing members of a file:</echo>
*
* <ftp action="list"
* server="${ftp.server}"
* userid="${ftp.user}"
* password="${ftp.password}"
* binary="false"
* verbose="true"
* remotedir="/QSYS.LIB/RPGUNIT.LIB/RPGUNITY1.FILE"
* systemTypeKey="OS/400"
* listing="ftp-listing.txt"
* >
* <fileset dir="./i5-downloads-file" casesensitive="false">
* <include name="run*.mbr" />
* </fileset>
* </ftp>
*
* Output:
* -------
*
* [echo] Listing members of a file:
* [ftp] listing files
* [ftp] listing RUN.MBR
* [ftp] listing RUNNER.MBR
* [ftp] listing RUNNERBND.MBR
* [ftp] 3 files listed
*
*
* Example 2, using ANT to list specific members of all files of a library:
* ------------------------------------------------------------------------
*
* <echo/>
* <echo>Listing members of all files of a library:</echo>
*
* <ftp action="list"
* server="${ftp.server}"
* userid="${ftp.user}"
* password="${ftp.password}"
* binary="false"
* verbose="true"
* remotedir="/QSYS.LIB/RPGUNIT.LIB"
* systemTypeKey="OS/400"
* listing="ftp-listing.txt"
* >
* <fileset dir="./i5-downloads-lib" casesensitive="false">
* <include name="**\run*.mbr" />
* </fileset>
* </ftp>
*
* Output:
* -------
*
* [echo] Listing members of all files of a library:
* [ftp] listing files
* [ftp] listing RPGUNIT1.FILE\RUN.MBR
* [ftp] listing RPGUNIT1.FILE\RUNRMT.MBR
* [ftp] listing RPGUNITT1.FILE\RUNT.MBR
* [ftp] listing RPGUNITY1.FILE\RUN.MBR
* [ftp] listing RPGUNITY1.FILE\RUNNER.MBR
* [ftp] listing RPGUNITY1.FILE\RUNNERBND.MBR
* [ftp] 6 files listed
*
*
* Example 3, using ANT to download specific members of a file:
* ------------------------------------------------------------
*
* <echo/>
* <echo>Downloading members of a file:</echo>
*
* <ftp action="get"
* server="${ftp.server}"
* userid="${ftp.user}"
* password="${ftp.password}"
* binary="false"
* verbose="true"
* remotedir="/QSYS.LIB/RPGUNIT.LIB/RPGUNITY1.FILE"
* systemTypeKey="OS/400"
* >
* <fileset dir="./i5-downloads-file" casesensitive="false">
* <include name="run*.mbr" />
* </fileset>
* </ftp>
*
* Output:
* -------
*
* [echo] Downloading members of a file:
* [ftp] getting files
* [ftp] transferring RUN.MBR to C:\workspaces\rdp_080\workspace\ANT - FTP\i5-downloads-file\RUN.MBR
* [ftp] transferring RUNNER.MBR to C:\workspaces\rdp_080\workspace\ANT - FTP\i5-downloads-file\RUNNER.MBR
* [ftp] transferring RUNNERBND.MBR to C:\workspaces\rdp_080\workspace\ANT - FTP\i5-downloads-file\RUNNERBND.MBR
* [ftp] 3 files retrieved
*
*
* Example 4, using ANT to download specific members of all files of a library:
* ----------------------------------------------------------------------------
*
* <echo/>
* <echo>Downloading members of all files of a library:</echo>
*
* <ftp action="get"
* server="${ftp.server}"
* userid="${ftp.user}"
* password="${ftp.password}"
* binary="false"
* verbose="true"
* remotedir="/QSYS.LIB/RPGUNIT.LIB"
* systemTypeKey="OS/400"
* >
* <fileset dir="./i5-downloads-lib" casesensitive="false">
* <include name="**\run*.mbr" />
* </fileset>
* </ftp>
*
* Output:
* -------
*
* [echo] Downloading members of all files of a library:
* [ftp] getting files
* [ftp] transferring RPGUNIT1.FILE\RUN.MBR to C:\work\rdp_080\space\ANT - FTP\i5-downloads\RPGUNIT1.FILE\RUN.MBR
* [ftp] transferring RPGUNIT1.FILE\RUNRMT.MBR to C:\work\rdp_080\space\ANT - FTP\i5-downloads\RPGUNIT1.FILE\RUNRMT.MBR
* [ftp] transferring RPGUNITT1.FILE\RUNT.MBR to C:\work\rdp_080\space\ANT - FTP\i5-downloads\RPGUNITT1.FILE\RUNT.MBR
* [ftp] transferring RPGUNITY1.FILE\RUN.MBR to C:\work\rdp_080\space\ANT - FTP\i5-downloads\RPGUNITY1.FILE\RUN.MBR
* [ftp] transferring RPGUNITY1.FILE\RUNNER.MBR to C:\work\rdp_080\space\ANT - FTP\i5-downloads\RPGUNITY1.FILE\RUNNER.MBR
* [ftp] transferring RPGUNITY1.FILE\RUNNERBND.MBR to C:\work\rdp_080\space\ANT - FTP\i5-downloads\RPGUNITY1.FILE\RUNNERBND.MBR
* [ftp] 6 files retrieved
*
*
* Example 5, using ANT to download a save file of a library:
* ----------------------------------------------------------
*
* <ftp action="get"
* server="${ftp.server}"
* userid="${ftp.user}"
* password="${ftp.password}"
* binary="true"
* verbose="true"
* remotedir="/QSYS.LIB/RPGUNIT.LIB"
* systemTypeKey="OS/400"
* >
* <fileset dir="./i5-downloads-savf" casesensitive="false">
* <include name="RPGUNIT.SAVF" />
* </fileset>
* </ftp>
*
* Output:
* -------
* [echo] Downloading save file:
* [ftp] getting files
* [ftp] transferring RPGUNIT.SAVF to C:\workspaces\rdp_080\workspace\net-Test\i5-downloads-lib\RPGUNIT.SAVF
* [ftp] 1 files retrieved
*
*
*/
public class OS400FTPEntryParser extends ConfigurableFTPFileEntryParserImpl {
private static final String DEFAULT_DATE_FORMAT = "yy/MM/dd HH:mm:ss"; // 01/11/09 12:30:24
private static final String REGEX = "(\\S+)\\s+" // user
+ "(?:(\\d+)\\s+)?" // size, empty for members
+ "(?:(\\S+)\\s+(\\S+)\\s+)?" // date stuff, empty for members
+ "(\\*STMF|\\*DIR|\\*FILE|\\*MEM)\\s+" // *STMF/*DIR/*FILE/*MEM
+ "((\\S+\\s*)+)?"; // file name, missing, when CWD is a *FILE
/**
* The default constructor for a OS400FTPEntryParser object.
*
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
*/
public OS400FTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of an OS400FTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public OS400FTPEntryParser(final FTPClientConfig config) {
super(REGEX);
configure(config);
}
/**
* Defines a default configuration to be used when this class is instantiated without a {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for this parser.
*/
@Override
protected FTPClientConfig getDefaultConfiguration() {
return new FTPClientConfig(FTPClientConfig.SYST_OS400, DEFAULT_DATE_FORMAT, null);
}
/**
*
* @param string String value that is checked for null or empty.
* @return true for null or empty values, else false.
*/
private boolean isNullOrEmpty(final String string) {
return string == null || string.isEmpty();
}
@Override
public FTPFile parseFTPEntry(final String entry) {
final FTPFile file = new FTPFile();
file.setRawListing(entry);
final int type;
if (matches(entry)) {
final String usr = group(1);
final String filesize = group(2);
String datestr = "";
if (!isNullOrEmpty(group(3)) || !isNullOrEmpty(group(4))) {
datestr = group(3) + " " + group(4);
}
final String typeStr = group(5);
String name = group(6);
boolean mustScanForPathSeparator = true;
try {
file.setTimestamp(super.parseTimestamp(datestr));
} catch (final ParseException e) {
// intentionally do nothing
}
if (typeStr.equalsIgnoreCase("*STMF")) {
type = FTPFile.FILE_TYPE;
if (isNullOrEmpty(filesize) || isNullOrEmpty(name)) {
return null;
}
} else if (typeStr.equalsIgnoreCase("*DIR")) {
type = FTPFile.DIRECTORY_TYPE;
if (isNullOrEmpty(filesize) || isNullOrEmpty(name)) {
return null;
}
} else if (typeStr.equalsIgnoreCase("*FILE")) {
// File, defines the structure of the data (columns of a row)
// but the data is stored in one or more members. Typically a
// source file contains multiple members whereas it is
// recommended (but not enforced) to use one member per data
// file.
// Save files are a special type of files which are used
// to save objects, e.g. for backups.
if ((name == null) || !name.toUpperCase(Locale.ROOT).endsWith(".SAVF")) {
return null;
}
mustScanForPathSeparator = false;
type = FTPFile.FILE_TYPE;
} else if (typeStr.equalsIgnoreCase("*MEM")) {
mustScanForPathSeparator = false;
type = FTPFile.FILE_TYPE;
if (isNullOrEmpty(name)) {
return null;
}
if (!(isNullOrEmpty(filesize) && isNullOrEmpty(datestr))) {
return null;
}
// Quick and dirty bug fix to make SelectorUtils work.
// Class SelectorUtils uses 'File.separator' to splitt
// a given path into pieces. But actually it had to
// use the separator of the FTP server, which is a forward
// slash in case of an AS/400.
name = name.replace('/', File.separatorChar);
} else {
type = FTPFile.UNKNOWN_TYPE;
}
file.setType(type);
file.setUser(usr);
try {
file.setSize(Long.parseLong(filesize));
} catch (final NumberFormatException e) {
// intentionally do nothing
}
if (name.endsWith("/")) {
name = name.substring(0, name.length() - 1);
}
if (mustScanForPathSeparator) {
final int pos = name.lastIndexOf('/');
if (pos > -1) {
name = name.substring(pos + 1);
}
}
file.setName(name);
return file;
}
return null;
}
}
ParserInitializationException.java 0000664 0000000 0000000 00000004010 14340477222 0036600 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
/**
* This class encapsulates all errors that may be thrown by the process of an FTPFileEntryParserFactory creating and instantiating an FTPFileEntryParser.
*/
public class ParserInitializationException extends RuntimeException {
private static final long serialVersionUID = 5563335279583210658L;
/**
* Constucts a ParserInitializationException with just a message
*
* @param message Exception message
*/
public ParserInitializationException(final String message) {
super(message);
}
/**
* Constucts a ParserInitializationException with a message and a root cause.
*
* @param message Exception message
* @param rootCause root cause throwable that caused this to be thrown
*/
public ParserInitializationException(final String message, final Throwable rootCause) {
super(message, rootCause);
}
/**
* returns the root cause of this exception or null if no root cause was specified.
*
* @return the root cause of this exception being thrown
* @deprecated use {@link #getCause()} instead
*/
@Deprecated
public Throwable getRootCause() {
return super.getCause();
}
}
RegexFTPFileEntryParserImpl.java 0000664 0000000 0000000 00000015274 14340477222 0036040 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.apache.commons.net.ftp.FTPFileEntryParserImpl;
/**
* This abstract class implements both the older FTPFileListParser and newer FTPFileEntryParser interfaces with default functionality. All the classes in the
* parser subpackage inherit from this.
*
* This is the base class for all regular expression based FTPFileEntryParser classes
*/
public abstract class RegexFTPFileEntryParserImpl extends FTPFileEntryParserImpl {
/**
* internal pattern the matcher tries to match, representing a file entry
*/
private Pattern pattern;
/**
* internal match result used by the parser
*/
private MatchResult result;
/**
* Internal PatternMatcher object used by the parser. It has protected scope in case subclasses want to make use of it for their own purposes.
*/
protected Matcher _matcher_;
/**
* The constructor for a RegexFTPFileEntryParserImpl object. The expression is compiled with flags = 0.
*
* @param regex The regular expression with which this object is initialized.
*
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen in normal conditions. It it is seen, this is a sign
* that a subclass has been created with a bad regular expression. Since the parser must be created before use, this means
* that any bad parser subclasses created from this will bomb very quickly, leading to easy detection.
*/
public RegexFTPFileEntryParserImpl(final String regex) {
compileRegex(regex, 0);
}
/**
* The constructor for a RegexFTPFileEntryParserImpl object.
*
* @param regex The regular expression with which this object is initialized.
* @param flags the flags to apply, see {@link Pattern#compile(String, int)}. Use 0 for none.
*
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen in normal conditions. It it is seen, this is a sign
* that a subclass has been created with a bad regular expression. Since the parser must be created before use, this means
* that any bad parser subclasses created from this will bomb very quickly, leading to easy detection.
* @since 3.4
*/
public RegexFTPFileEntryParserImpl(final String regex, final int flags) {
compileRegex(regex, flags);
}
/**
* Compile the regex and store the {@link Pattern}.
*
* This is an internal method to do the work so the constructor does not have to call an overrideable method.
*
* @param regex the expression to compile
* @param flags the flags to apply, see {@link Pattern#compile(String, int)}. Use 0 for none.
* @throws IllegalArgumentException if the regex cannot be compiled
*/
private void compileRegex(final String regex, final int flags) {
try {
pattern = Pattern.compile(regex, flags);
} catch (final PatternSyntaxException pse) {
throw new IllegalArgumentException("Unparseable regex supplied: " + regex);
}
}
/**
* Convenience method
*
* @return the number of groups() in the internal MatchResult.
*/
public int getGroupCnt() {
if (this.result == null) {
return 0;
}
return this.result.groupCount();
}
/**
* For debugging purposes - returns a string shows each match group by number.
*
* @return a string shows each match group by number.
*/
public String getGroupsAsString() {
final StringBuilder b = new StringBuilder();
for (int i = 1; i <= this.result.groupCount(); i++) {
b.append(i).append(") ").append(this.result.group(i)).append(System.lineSeparator());
}
return b.toString();
}
/**
* Convenience method delegates to the internal MatchResult's group() method.
*
* @param matchnum match group number to be retrieved
*
* @return the content of the matchnum'th group of the internal match or null if this method is called without a match having been made.
*/
public String group(final int matchnum) {
if (this.result == null) {
return null;
}
return this.result.group(matchnum);
}
/**
* Convenience method delegates to the internal MatchResult's matches() method.
*
* @param s the String to be matched
* @return true if s matches this object's regular expression.
*/
public boolean matches(final String s) {
this.result = null;
_matcher_ = pattern.matcher(s);
if (_matcher_.matches()) {
this.result = _matcher_.toMatchResult();
}
return null != this.result;
}
/**
* Alter the current regular expression being utilised for entry parsing and create a new {@link Pattern} instance.
*
* @param regex The new regular expression
* @return true
* @since 2.0
* @throws IllegalArgumentException if the regex cannot be compiled
*/
public boolean setRegex(final String regex) {
compileRegex(regex, 0);
return true;
}
/**
* Alter the current regular expression being utilised for entry parsing and create a new {@link Pattern} instance.
*
* @param regex The new regular expression
* @param flags the flags to apply, see {@link Pattern#compile(String, int)}. Use 0 for none.
* @return true
* @since 3.4
* @throws IllegalArgumentException if the regex cannot be compiled
*/
public boolean setRegex(final String regex, final int flags) {
compileRegex(regex, flags);
return true;
}
}
UnixFTPEntryParser.java 0000664 0000000 0000000 00000030537 14340477222 0034266 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.text.ParseException;
import java.util.List;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
/**
* Implementation FTPFileEntryParser and FTPFileListParser for standard Unix Systems.
*
* This class is based on the logic of Daniel Savarese's DefaultFTPListParser, but adapted to use regular expressions and to fit the new FTPFileEntryParser
* interface.
*
* @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)
*/
public class UnixFTPEntryParser extends ConfigurableFTPFileEntryParserImpl {
static final String DEFAULT_DATE_FORMAT = "MMM d yyyy"; // Nov 9 2001
static final String DEFAULT_RECENT_DATE_FORMAT = "MMM d HH:mm"; // Nov 9 20:06
static final String NUMERIC_DATE_FORMAT = "yyyy-MM-dd HH:mm"; // 2001-11-09 20:06
// Suffixes used in Japanese listings after the numeric values
private static final String JA_MONTH = "\u6708";
private static final String JA_DAY = "\u65e5";
private static final String JA_YEAR = "\u5e74";
private static final String DEFAULT_DATE_FORMAT_JA = "M'" + JA_MONTH + "' d'" + JA_DAY + "' yyyy'" + JA_YEAR + "'"; // 6月 3日 2003年
private static final String DEFAULT_RECENT_DATE_FORMAT_JA = "M'" + JA_MONTH + "' d'" + JA_DAY + "' HH:mm"; // 8月 17日 20:10
/**
* Some Linux distributions are now shipping an FTP server which formats file listing dates in an all-numeric format: "yyyy-MM-dd HH:mm. This
* is a very welcome development, and hopefully it will soon become the standard. However, since it is so new, for now, and possibly forever, we merely
* accomodate it, but do not make it the default.
* UnixFTPEntryParser(FTPClientConfig). Steve Cohen - 2005-04-17
*/
public static final FTPClientConfig NUMERIC_DATE_CONFIG = new FTPClientConfig(FTPClientConfig.SYST_UNIX, NUMERIC_DATE_FORMAT, null);
/**
* this is the regular expression used by this parser.
*
* Permissions: r the file is readable w the file is writable x the file is executable - the indicated permission is not granted L mandatory locking occurs
* during access (the set-group-ID bit is on and the group execution bit is off) s the set-user-ID or set-group-ID bit is on, and the corresponding user or
* group execution bit is also on S undefined bit-state (the set-user-ID bit is on and the user execution bit is off) t the 1000 (octal) bit, or sticky bit,
* is on [see chmod(1)], and execution is on T the 1000 bit is turned on, and execution is off (undefined bit- state) e z/OS external link bit Final letter
* may be appended: + file has extended security attributes (e.g. ACL) Note: local listings on MacOSX also use '@'; this is not allowed for here as does not
* appear to be shown by FTP servers {@code @} file has extended attributes
*/
private static final String REGEX = "([bcdelfmpSs-])" // file type
+ "(((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-])))\\+?" // permissions
+ "\\s*" // separator TODO why allow it to be omitted??
+ "(\\d+)" // link count
+ "\\s+" // separator
+ "(?:(\\S+(?:\\s\\S+)*?)\\s+)?" // owner name (optional spaces)
+ "(?:(\\S+(?:\\s\\S+)*)\\s+)?" // group name (optional spaces)
+ "(\\d+(?:,\\s*\\d+)?)" // size or n,m
+ "\\s+" // separator
/*
* numeric or standard format date: yyyy-mm-dd (expecting hh:mm to follow) MMM [d]d [d]d MMM N.B. use non-space for MMM to allow for languages such
* as German which use diacritics (e.g. umlaut) in some abbreviations. Japanese uses numeric day and month with suffixes to distinguish them [d]dXX
* [d]dZZ
*/
+ "(" + "(?:\\d+[-/]\\d+[-/]\\d+)" + // yyyy-mm-dd
"|(?:\\S{3}\\s+\\d{1,2})" + // MMM [d]d
"|(?:\\d{1,2}\\s+\\S{3})" + // [d]d MMM
"|(?:\\d{1,2}" + JA_MONTH + "\\s+\\d{1,2}" + JA_DAY + ")" + ")"
+ "\\s+" // separator
/*
* year (for non-recent standard format) - yyyy or time (for numeric or recent standard format) [h]h:mm or Japanese year - yyyyXX
*/
+ "((?:\\d+(?::\\d+)?)|(?:\\d{4}" + JA_YEAR + "))" // (20)
+ "\\s" // separator
+ "(.*)"; // the rest (21)
// if true, leading spaces are trimmed from file names
// this was the case for the original implementation
final boolean trimLeadingSpaces; // package protected for access from test code
/**
* The default constructor for a UnixFTPEntryParser object.
*
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
*/
public UnixFTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of a UnixFTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public UnixFTPEntryParser(final FTPClientConfig config) {
this(config, false);
}
/**
* This constructor allows the creation of a UnixFTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @param trimLeadingSpaces if {@code true}, trim leading spaces from file names
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 3.4
*/
public UnixFTPEntryParser(final FTPClientConfig config, final boolean trimLeadingSpaces) {
super(REGEX);
configure(config);
this.trimLeadingSpaces = trimLeadingSpaces;
}
/**
* Defines a default configuration to be used when this class is instantiated without a {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for this parser.
*/
@Override
protected FTPClientConfig getDefaultConfiguration() {
return new FTPClientConfig(FTPClientConfig.SYST_UNIX, DEFAULT_DATE_FORMAT, DEFAULT_RECENT_DATE_FORMAT);
}
/**
* Parses a line of a unix (standard) FTP server file listing and converts it into a usable format in the form of an FTPFile instance. If the
* file listing line doesn't describe a file, null is returned, otherwise a FTPFile instance representing the files in the
* directory is returned.
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
final FTPFile file = new FTPFile();
file.setRawListing(entry);
final int type;
boolean isDevice = false;
if (matches(entry)) {
final String typeStr = group(1);
final String hardLinkCount = group(15);
final String usr = group(16);
final String grp = group(17);
final String filesize = group(18);
final String datestr = group(19) + " " + group(20);
String name = group(21);
if (trimLeadingSpaces) {
name = name.replaceFirst("^\\s+", "");
}
try {
if (group(19).contains(JA_MONTH)) { // special processing for Japanese format
final FTPTimestampParserImpl jaParser = new FTPTimestampParserImpl();
jaParser.configure(new FTPClientConfig(FTPClientConfig.SYST_UNIX, DEFAULT_DATE_FORMAT_JA, DEFAULT_RECENT_DATE_FORMAT_JA));
file.setTimestamp(jaParser.parseTimestamp(datestr));
} else {
file.setTimestamp(super.parseTimestamp(datestr));
}
} catch (final ParseException e) {
// intentionally do nothing
}
// A 'whiteout' file is an ARTIFICIAL entry in any of several types of
// 'translucent' filesystems, of which a 'union' filesystem is one.
// bcdelfmpSs-
switch (typeStr.charAt(0)) {
case 'd':
type = FTPFile.DIRECTORY_TYPE;
break;
case 'e': // NET-39 => z/OS external link
type = FTPFile.SYMBOLIC_LINK_TYPE;
break;
case 'l':
type = FTPFile.SYMBOLIC_LINK_TYPE;
break;
case 'b':
case 'c':
isDevice = true;
type = FTPFile.FILE_TYPE; // TODO change this if DEVICE_TYPE implemented
break;
case 'f':
case '-':
type = FTPFile.FILE_TYPE;
break;
default: // e.g. ? and w = whiteout
type = FTPFile.UNKNOWN_TYPE;
}
file.setType(type);
int g = 4;
for (int access = 0; access < 3; access++, g += 4) {
// Use != '-' to avoid having to check for suid and sticky bits
file.setPermission(access, FTPFile.READ_PERMISSION, !group(g).equals("-"));
file.setPermission(access, FTPFile.WRITE_PERMISSION, !group(g + 1).equals("-"));
final String execPerm = group(g + 2);
file.setPermission(access, FTPFile.EXECUTE_PERMISSION, !execPerm.equals("-") && !Character.isUpperCase(execPerm.charAt(0)));
}
if (!isDevice) {
try {
file.setHardLinkCount(Integer.parseInt(hardLinkCount));
} catch (final NumberFormatException e) {
// intentionally do nothing
}
}
file.setUser(usr);
file.setGroup(grp);
try {
file.setSize(Long.parseLong(filesize));
} catch (final NumberFormatException e) {
// intentionally do nothing
}
// oddball cases like symbolic links, file names
// with spaces in them.
if (type == FTPFile.SYMBOLIC_LINK_TYPE) {
final int end = name.indexOf(" -> ");
// Give up if no link indicator is present
if (end == -1) {
file.setName(name);
} else {
file.setName(name.substring(0, end));
file.setLink(name.substring(end + 4));
}
} else {
file.setName(name);
}
return file;
}
return null;
}
/**
* Preparse the list to discard "total nnn" lines
*/
@Override
public List
* "1-JUN.LIS;1 9/9 2-JUN-1998 07:32:04 [GROUP,OWNER] (RWED,RWED,RWED,RE)",
* "1-JUN.LIS;2 9/9 2-JUN-1998 07:32:04 [GROUP,OWNER] (RWED,RWED,RWED,RE)",
* "DATA.DIR;1 1/9 2-JUN-1998 07:32:04 [GROUP,OWNER] (RWED,RWED,RWED,RE)",
*
* REGEX is not a valid regular expression.
*/
public VMSFTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of a VMSFTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public VMSFTPEntryParser(final FTPClientConfig config) {
super(REGEX);
configure(config);
}
/**
* Defines a default configuration to be used when this class is instantiated without a {@link FTPClientConfig FTPClientConfig} parameter being specified.
*
* @return the default configuration for this parser.
*/
@Override
protected FTPClientConfig getDefaultConfiguration() {
return new FTPClientConfig(FTPClientConfig.SYST_VMS, DEFAULT_DATE_FORMAT, null);
}
protected boolean isVersioning() {
return false;
}
/**
* DO NOT USE
*
* @param listStream the stream
* @return the array of files
* @throws IOException on error
* @deprecated (2.2) No other FTPFileEntryParser implementations have this method.
*/
@Deprecated
public FTPFile[] parseFileList(final java.io.InputStream listStream) throws IOException {
final org.apache.commons.net.ftp.FTPListParseEngine engine = new org.apache.commons.net.ftp.FTPListParseEngine(this);
engine.readServerList(listStream, null);
return engine.getFiles();
}
/**
* Parses a line of a VMS FTP server file listing and converts it into a usable format in the form of an FTPFile instance. If the file
* listing line doesn't describe a file, null is returned, otherwise a FTPFile instance representing the files in the
* directory is returned.
*
* @param entry A line of text from the file listing
* @return An FTPFile instance corresponding to the supplied entry
*/
@Override
public FTPFile parseFTPEntry(final String entry) {
// one block in VMS equals 512 bytes
final long longBlock = 512;
if (matches(entry)) {
final FTPFile f = new FTPFile();
f.setRawListing(entry);
String name = group(1);
final String size = group(2);
final String datestr = group(3) + " " + group(4);
final String owner = group(5);
final String permissions[] = new String[3];
permissions[0] = group(9);
permissions[1] = group(10);
permissions[2] = group(11);
try {
f.setTimestamp(super.parseTimestamp(datestr));
} catch (final ParseException e) {
// intentionally do nothing
}
final String grp;
final String user;
final StringTokenizer t = new StringTokenizer(owner, ",");
switch (t.countTokens()) {
case 1:
grp = null;
user = t.nextToken();
break;
case 2:
grp = t.nextToken();
user = t.nextToken();
break;
default:
grp = null;
user = null;
}
if (name.lastIndexOf(".DIR") != -1) {
f.setType(FTPFile.DIRECTORY_TYPE);
} else {
f.setType(FTPFile.FILE_TYPE);
}
// set FTPFile name
// Check also for versions to be returned or not
if (!isVersioning()) {
name = name.substring(0, name.lastIndexOf(';'));
}
f.setName(name);
// size is retreived in blocks and needs to be put in bytes
// for us humans and added to the FTPFile array
final long sizeInBytes = Long.parseLong(size) * longBlock;
f.setSize(sizeInBytes);
f.setGroup(grp);
f.setUser(user);
// set group and owner
// Set file permission.
// VMS has (SYSTEM,OWNER,GROUP,WORLD) users that can contain
// R (read) W (write) E (execute) D (delete)
// iterate for OWNER GROUP WORLD permissions
for (int access = 0; access < 3; access++) {
final String permission = permissions[access];
f.setPermission(access, FTPFile.READ_PERMISSION, permission.indexOf('R') >= 0);
f.setPermission(access, FTPFile.WRITE_PERMISSION, permission.indexOf('W') >= 0);
f.setPermission(access, FTPFile.EXECUTE_PERMISSION, permission.indexOf('E') >= 0);
}
return f;
}
return null;
}
// DEPRECATED METHODS - for API compatibility only - DO NOT USE
/**
* Reads the next entry using the supplied BufferedReader object up to whatever delimits one entry from the next. This parser cannot use the default
* implementation of simply calling BufferedReader.readLine(), because one entry may span multiple lines.
*
* @param reader The BufferedReader object from which entries are to be read.
*
* @return A string representing the next ftp entry or null if none found.
* @throws IOException thrown on any IO Error reading from the reader.
*/
@Override
public String readNextEntry(final BufferedReader reader) throws IOException {
String line = reader.readLine();
final StringBuilder entry = new StringBuilder();
while (line != null) {
if (line.startsWith("Directory") || line.startsWith("Total")) {
line = reader.readLine();
continue;
}
entry.append(line);
if (line.trim().endsWith(")")) {
break;
}
line = reader.readLine();
}
return entry.length() == 0 ? null : entry.toString();
}
}
VMSVersioningFTPEntryParser.java 0000664 0000000 0000000 00000013365 14340477222 0036054 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ftp/parser /*
* 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.ftp.parser;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.apache.commons.net.ftp.FTPClientConfig;
/**
* Special implementation VMSFTPEntryParser with versioning turned on. This parser removes all duplicates and only leaves the version with the highest version
* number for each file name.
*
* "1-JUN.LIS;1 9/9 2-JUN-1998 07:32:04 [GROUP,OWNER] (RWED,RWED,RWED,RE)",
* "1-JUN.LIS;2 9/9 2-JUN-1998 07:32:04 [GROUP,OWNER] (RWED,RWED,RWED,RE)",
* "DATA.DIR;1 1/9 2-JUN-1998 07:32:04 [GROUP,OWNER] (RWED,RWED,RWED,RE)",
*
*
* @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)
*/
public class VMSVersioningFTPEntryParser extends VMSFTPEntryParser {
private static final String PRE_PARSE_REGEX = "(.*?);([0-9]+)\\s*.*";
private final Pattern preparsePattern;
/**
* Constructor for a VMSFTPEntryParser object.
*
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
*/
public VMSVersioningFTPEntryParser() {
this(null);
}
/**
* This constructor allows the creation of a VMSVersioningFTPEntryParser object with something other than the default configuration.
*
* @param config The {@link FTPClientConfig configuration} object used to configure this parser.
* @throws IllegalArgumentException Thrown if the regular expression is unparseable. Should not be seen under normal conditions. It it is seen, this is a
* sign that REGEX is not a valid regular expression.
* @since 1.4
*/
public VMSVersioningFTPEntryParser(final FTPClientConfig config) {
configure(config);
try {
// _preparse_matcher_ = new Perl5Matcher();
preparsePattern = Pattern.compile(PRE_PARSE_REGEX);
} catch (final PatternSyntaxException pse) {
throw new IllegalArgumentException("Unparseable regex supplied: " + PRE_PARSE_REGEX);
}
}
@Override
protected boolean isVersioning() {
return true;
}
/**
* Implement hook provided for those implementers (such as VMSVersioningFTPEntryParser, and possibly others) which return multiple files with the same name
* to remove the duplicates ..
*
* @param original Original list
*
* @return Original list purged of duplicates
*/
@Override
public ListDISCONNECTED_STATE.
*/
public IMAP() {
setDefaultPort(DEFAULT_PORT);
state = IMAPState.DISCONNECTED_STATE;
_reader = null;
__writer = null;
replyLines = new ArrayList<>();
createCommandSupport();
}
/**
* Performs connection initialization and sets state to {@link IMAPState#NOT_AUTH_STATE}.
*/
@Override
protected void _connectAction_() throws IOException {
super._connectAction_();
_reader = new CRLFLineReader(new InputStreamReader(_input_, __DEFAULT_ENCODING));
__writer = new BufferedWriter(new OutputStreamWriter(_output_, __DEFAULT_ENCODING));
final int tmo = getSoTimeout();
if (tmo <= 0) { // none set currently
setSoTimeout(connectTimeout); // use connect timeout to ensure we don't block forever
}
getReply(false); // untagged response
if (tmo <= 0) {
setSoTimeout(tmo); // restore the original value
}
setState(IMAPState.NOT_AUTH_STATE);
}
/**
* Disconnects the client from the server, and sets the state to DISCONNECTED_STATE . The reply text information from the last issued command
* is voided to allow garbage collection of the memory used to store that information.
*
* @throws IOException If there is an error in disconnecting.
*/
@Override
public void disconnect() throws IOException {
super.disconnect();
_reader = null;
__writer = null;
replyLines.clear();
setState(IMAPState.DISCONNECTED_STATE);
}
/**
* Sends a command to the server and return whether successful.
*
* @param command The IMAP command to send (one of the IMAPCommand constants).
* @return {@code true} if the command was successful
* @throws IOException on error
*/
public boolean doCommand(final IMAPCommand command) throws IOException {
return IMAPReply.isSuccess(sendCommand(command));
}
/**
* Sends a command and arguments to the server and return whether successful.
*
* @param command The IMAP command to send (one of the IMAPCommand constants).
* @param args The command arguments.
* @return {@code true} if the command was successful
* @throws IOException on error
*/
public boolean doCommand(final IMAPCommand command, final String args) throws IOException {
return IMAPReply.isSuccess(sendCommand(command, args));
}
/**
* Overrides {@link SocketClient#fireReplyReceived(int, String)} so as to avoid creating the reply string if there are no listeners to invoke.
*
* @param replyCode passed to the listeners
* @param ignored the string is only created if there are listeners defined.
* @see #getReplyString()
* @since 3.4
*/
@Override
protected void fireReplyReceived(final int replyCode, final String ignored) {
if (getCommandSupport().getListenerCount() > 0) {
getCommandSupport().fireReplyReceived(replyCode, getReplyString());
}
}
/**
* Generates a new command ID (tag) for a command.
*
* @return a new command ID (tag) for an IMAP command.
*/
protected String generateCommandID() {
final String res = new String(initialID);
// "increase" the ID for the next call
boolean carry = true; // want to increment initially
for (int i = initialID.length - 1; carry && i >= 0; i--) {
if (initialID[i] == 'Z') {
initialID[i] = 'A';
} else {
initialID[i]++;
carry = false; // did not wrap round
}
}
return res;
}
/**
* Get the reply for a command that expects a tagged response.
*
* @throws IOException
*/
private void getReply() throws IOException {
getReply(true); // tagged response
}
/**
* Get the reply for a command, reading the response until the reply is found.
*
* @param wantTag {@code true} if the command expects a tagged response.
* @throws IOException
*/
private void getReply(final boolean wantTag) throws IOException {
replyLines.clear();
String line = _reader.readLine();
if (line == null) {
throw new EOFException("Connection closed without indication.");
}
replyLines.add(line);
if (wantTag) {
while (IMAPReply.isUntagged(line)) {
int literalCount = IMAPReply.literalCount(line);
final boolean isMultiLine = literalCount >= 0;
while (literalCount >= 0) {
line = _reader.readLine();
if (line == null) {
throw new EOFException("Connection closed without indication.");
}
replyLines.add(line);
literalCount -= line.length() + 2; // Allow for CRLF
}
if (isMultiLine) {
final IMAPChunkListener il = chunkListener;
if (il != null) {
final boolean clear = il.chunkReceived(this);
if (clear) {
fireReplyReceived(IMAPReply.PARTIAL, getReplyString());
replyLines.clear();
}
}
}
line = _reader.readLine(); // get next chunk or final tag
if (line == null) {
throw new EOFException("Connection closed without indication.");
}
replyLines.add(line);
}
// check the response code on the last line
replyCode = IMAPReply.getReplyCode(line);
} else {
replyCode = IMAPReply.getUntaggedReplyCode(line);
}
fireReplyReceived(replyCode, getReplyString());
}
/**
* Returns the reply to the last command sent to the server. The value is a single string containing all the reply lines including newlines.
*
* @return The last server response.
*/
public String getReplyString() {
final StringBuilder buffer = new StringBuilder(256);
for (final String s : replyLines) {
buffer.append(s);
buffer.append(SocketClient.NETASCII_EOL);
}
return buffer.toString();
}
/**
* Returns an array of lines received as a reply to the last command sent to the server. The lines have end of lines truncated.
*
* @return The last server response.
*/
public String[] getReplyStrings() {
return replyLines.toArray(NetConstants.EMPTY_STRING_ARRAY);
}
/**
* Returns the current IMAP client state.
*
* @return The current IMAP client state.
*/
public IMAP.IMAPState getState() {
return state;
}
/**
* Sends a command with no arguments to the server and returns the reply code.
*
* @param command The IMAP command to send (one of the IMAPCommand constants).
* @return The server reply code (see IMAPReply).
* @throws IOException on error
**/
public int sendCommand(final IMAPCommand command) throws IOException {
return sendCommand(command, null);
}
/**
* Sends a command and arguments to the server and returns the reply code.
*
* @param command The IMAP command to send (one of the IMAPCommand constants).
* @param args The command arguments.
* @return The server reply code (see IMAPReply).
* @throws IOException on error
*/
public int sendCommand(final IMAPCommand command, final String args) throws IOException {
return sendCommand(command.getIMAPCommand(), args);
}
/**
* Sends a command with no arguments to the server and returns the reply code.
*
* @param command The IMAP command to send.
* @return The server reply code (see IMAPReply).
* @throws IOException on error
*/
public int sendCommand(final String command) throws IOException {
return sendCommand(command, null);
}
/**
* Sends a command an arguments to the server and returns the reply code.
*
* @param command The IMAP command to send.
* @param args The command arguments.
* @return The server reply code (see IMAPReply).
* @throws IOException on error
*/
public int sendCommand(final String command, final String args) throws IOException {
return sendCommandWithID(generateCommandID(), command, args);
}
/**
* Sends a command an arguments to the server and returns the reply code.
*
* @param commandID The ID (tag) of the command.
* @param command The IMAP command to send.
* @param args The command arguments.
* @return The server reply code (either IMAPReply.OK, IMAPReply.NO or IMAPReply.BAD).
*/
private int sendCommandWithID(final String commandID, final String command, final String args) throws IOException {
final StringBuilder __commandBuffer = new StringBuilder();
if (commandID != null) {
__commandBuffer.append(commandID);
__commandBuffer.append(' ');
}
__commandBuffer.append(command);
if (args != null) {
__commandBuffer.append(' ');
__commandBuffer.append(args);
}
__commandBuffer.append(SocketClient.NETASCII_EOL);
final String message = __commandBuffer.toString();
__writer.write(message);
__writer.flush();
fireCommandSent(command, message);
getReply();
return replyCode;
}
/**
* Sends data to the server and returns the reply code.
*
* @param command The IMAP command to send.
* @return The server reply code (see IMAPReply).
* @throws IOException on error
*/
public int sendData(final String command) throws IOException {
return sendCommandWithID(null, command, null);
}
/**
* Sets the current chunk listener. If a listener is registered and the implementation returns true, then any registered
* {@link org.apache.commons.net.PrintCommandListener PrintCommandListener} instances will be invoked with the partial response and a status of
* {@link IMAPReply#PARTIAL} to indicate that the final reply code is not yet known.
*
* @param listener the class to use, or {@code null} to disable
* @see #TRUE_CHUNK_LISTENER
* @since 3.4
*/
public void setChunkListener(final IMAPChunkListener listener) {
chunkListener = listener;
}
/**
* Sets IMAP client state. This must be one of the _STATE constants.
*
* @param state The new state.
*/
protected void setState(final IMAP.IMAPState state) {
this.state = state;
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/imap/IMAPClient.java 0000664 0000000 0000000 00000053533 14340477222 0031400 0 ustar 00root root 0000000 0000000 /*
* 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.imap;
import java.io.IOException;
/**
* The IMAPClient class provides the basic functionalities found in an IMAP client.
*/
public class IMAPClient extends IMAP {
/**
* The message data item names for the FETCH command defined in RFC 3501.
*/
public enum FETCH_ITEM_NAMES {
/** Macro equivalent to: (FLAGS INTERNALDATE RFC822.SIZE ENVELOPE). */
ALL,
/** Macro equivalent to: (FLAGS INTERNALDATE RFC822.SIZE). */
FAST,
/** Macro equivalent to: (FLAGS INTERNALDATE RFC822.SIZE ENVELOPE BODY). */
FULL,
/** Non-extensible form of BODYSTRUCTURE or the text of a particular body section. */
BODY,
/** The [MIME-IMB] body structure of the message. */
BODYSTRUCTURE,
/** The envelope structure of the message. */
ENVELOPE,
/** The flags that are set for this message. */
FLAGS,
/** The internal date of the message. */
INTERNALDATE,
/** A prefix for RFC-822 item names. */
RFC822,
/** The unique identifier for the message. */
UID
}
/**
* The search criteria defined in RFC 3501.
*/
public enum SEARCH_CRITERIA {
/** All messages in the mailbox. */
ALL,
/** Messages with the \Answered flag set. */
ANSWERED,
/**
* Messages that contain the specified string in the envelope structure's BCC field.
*/
BCC,
/**
* Messages whose internal date (disregarding time and time zone) is earlier than the specified date.
*/
BEFORE,
/**
* Messages that contain the specified string in the body of the message.
*/
BODY,
/**
* Messages that contain the specified string in the envelope structure's CC field.
*/
CC,
/** Messages with the \Deleted flag set. */
DELETED,
/** Messages with the \Draft flag set. */
DRAFT,
/** Messages with the \Flagged flag set. */
FLAGGED,
/**
* Messages that contain the specified string in the envelope structure's FROM field.
*/
FROM,
/**
* Messages that have a header with the specified field-name (as defined in [RFC-2822]) and that contains the specified string in the text of the header
* (what comes after the colon). If the string to search is zero-length, this matches all messages that have a header line with the specified field-name
* regardless of the contents.
*/
HEADER,
/** Messages with the specified keyword flag set. */
KEYWORD,
/**
* Messages with an [RFC-2822] size larger than the specified number of octets.
*/
LARGER,
/**
* Messages that have the \Recent flag set but not the \Seen flag. This is functionally equivalent to "(RECENT UNSEEN)".
*/
NEW,
/** Messages that do not match the specified search key. */
NOT,
/**
* Messages that do not have the \Recent flag set. This is functionally equivalent to "NOT RECENT" (as opposed to "NOT NEW").
*/
OLD,
/**
* Messages whose internal date (disregarding time and time zone) is within the specified date.
*/
ON,
/** Messages that match either search key. */
OR,
/** Messages that have the \Recent flag set. */
RECENT,
/** Messages that have the \Seen flag set. */
SEEN,
/**
* Messages whose [RFC-2822] Date: header (disregarding time and time zone) is earlier than the specified date.
*/
SENTBEFORE,
/**
* Messages whose [RFC-2822] Date: header (disregarding time and time zone) is within the specified date.
*/
SENTON,
/**
* Messages whose [RFC-2822] Date: header (disregarding time and time zone) is within or later than the specified date.
*/
SENTSINCE,
/**
* Messages whose internal date (disregarding time and time zone) is within or later than the specified date.
*/
SINCE,
/**
* Messages with an [RFC-2822] size smaller than the specified number of octets.
*/
SMALLER,
/**
* Messages that contain the specified string in the envelope structure's SUBJECT field.
*/
SUBJECT,
/**
* Messages that contain the specified string in the header or body of the message.
*/
TEXT,
/**
* Messages that contain the specified string in the envelope structure's TO field.
*/
TO,
/**
* Messages with unique identifiers corresponding to the specified unique identifier set. Sequence set ranges are permitted.
*/
UID,
/** Messages that do not have the \Answered flag set. */
UNANSWERED,
/** Messages that do not have the \Deleted flag set. */
UNDELETED,
/** Messages that do not have the \Draft flag set. */
UNDRAFT,
/** Messages that do not have the \Flagged flag set. */
UNFLAGGED,
/** Messages that do not have the specified keyword flag set. */
UNKEYWORD,
/** Messages that do not have the \Seen flag set. */
UNSEEN
}
// --------- commands available in all states
/**
* The status data items defined in RFC 3501.
*/
public enum STATUS_DATA_ITEMS {
/** The number of messages in the mailbox. */
MESSAGES,
/** The number of messages with the \Recent flag set. */
RECENT,
/** The next unique identifier value of the mailbox. */
UIDNEXT,
/** The unique identifier validity value of the mailbox. */
UIDVALIDITY,
/** The number of messages which do not have the \Seen flag set. */
UNSEEN
}
private static final char DQUOTE = '"';
private static final String DQUOTE_S = "\"";
// --------- commands available in the not-authenticated state
// STARTTLS skipped - see IMAPSClient.
// AUTHENTICATE skipped - see AuthenticatingIMAPClient.
/**
* Send an APPEND command to the server.
*
* @param mailboxName The mailbox name.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
* @deprecated (3.4) Does not work; the message body is not optional. Use {@link #append(String, String, String, String)} instead.
*/
@Deprecated
public boolean append(final String mailboxName) throws IOException {
return append(mailboxName, null, null);
}
// --------- commands available in the authenticated state
/**
* Send an APPEND command to the server.
*
* @param mailboxName The mailbox name.
* @param flags The flag parenthesized list (optional).
* @param datetime The date/time string (optional).
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
* @deprecated (3.4) Does not work; the message body is not optional. Use {@link #append(String, String, String, String)} instead.
*/
@Deprecated
public boolean append(final String mailboxName, final String flags, final String datetime) throws IOException {
String args = mailboxName;
if (flags != null) {
args += " " + flags;
}
if (datetime != null) {
if (datetime.charAt(0) == '{') {
args += " " + datetime;
} else {
args += " {" + datetime + "}";
}
}
return doCommand(IMAPCommand.APPEND, args);
}
/**
* Send an APPEND command to the server.
*
* @param mailboxName The mailbox name.
* @param flags The flag parenthesized list (optional).
* @param datetime The date/time string (optional).
* @param message The message to append.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
* @since 3.4
*/
public boolean append(final String mailboxName, final String flags, final String datetime, final String message) throws IOException {
final StringBuilder args = new StringBuilder(quoteMailboxName(mailboxName));
if (flags != null) {
args.append(" ").append(flags);
}
if (datetime != null) {
args.append(" ");
if (datetime.charAt(0) == DQUOTE) {
args.append(datetime);
} else {
args.append(DQUOTE).append(datetime).append(DQUOTE);
}
}
args.append(" ");
// String literal (probably not used much - if at all)
if (message.startsWith(DQUOTE_S) && message.endsWith(DQUOTE_S)) {
args.append(message);
return doCommand(IMAPCommand.APPEND, args.toString());
}
args.append('{').append(message.getBytes(IMAP.__DEFAULT_ENCODING).length).append('}'); // length of message
final int status = sendCommand(IMAPCommand.APPEND, args.toString());
return IMAPReply.isContinuation(status) // expecting continuation response
&& IMAPReply.isSuccess(sendData(message)); // if so, send the data
}
/**
* Send a CAPABILITY command to the server.
*
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs
*/
public boolean capability() throws IOException {
return doCommand(IMAPCommand.CAPABILITY);
}
/**
* Send a CHECK command to the server.
*
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean check() throws IOException {
return doCommand(IMAPCommand.CHECK);
}
/**
* Send a CLOSE command to the server.
*
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean close() throws IOException {
return doCommand(IMAPCommand.CLOSE);
}
/**
* Send a COPY command to the server.
*
* @param sequenceSet The sequence set to fetch.
* @param mailboxName The mailbox name.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean copy(final String sequenceSet, final String mailboxName) throws IOException {
return doCommand(IMAPCommand.COPY, sequenceSet + " " + quoteMailboxName(mailboxName));
}
/**
* Send a CREATE command to the server.
*
* @param mailboxName The mailbox name to create.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean create(final String mailboxName) throws IOException {
return doCommand(IMAPCommand.CREATE, quoteMailboxName(mailboxName));
}
/**
* Send a DELETE command to the server.
*
* @param mailboxName The mailbox name to delete.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean delete(final String mailboxName) throws IOException {
return doCommand(IMAPCommand.DELETE, quoteMailboxName(mailboxName));
}
/**
* Send an EXAMINE command to the server.
*
* @param mailboxName The mailbox name to examine.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean examine(final String mailboxName) throws IOException {
return doCommand(IMAPCommand.EXAMINE, quoteMailboxName(mailboxName));
}
/**
* Send an EXPUNGE command to the server.
*
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean expunge() throws IOException {
return doCommand(IMAPCommand.EXPUNGE);
}
/**
* Send a FETCH command to the server.
*
* @param sequenceSet The sequence set to fetch (e.g. 1:4,6,11,100:*)
* @param itemNames The item names for the FETCH command. (e.g. BODY.PEEK[HEADER.FIELDS (SUBJECT)]) If multiple item names are requested, these must be
* enclosed in parentheses, e.g. "(UID FLAGS BODY.PEEK[])"
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
* @see #getReplyString()
* @see #getReplyStrings()
*/
public boolean fetch(final String sequenceSet, final String itemNames) throws IOException {
return doCommand(IMAPCommand.FETCH, sequenceSet + " " + itemNames);
}
/**
* Send a LIST command to the server. Quotes the parameters if necessary.
*
* @param refName The reference name If empty, indicates that the mailbox name is interpreted as by SELECT.
* @param mailboxName The mailbox name. If empty, this is a special request to return the hierarchy delimiter and the root name of the name given in the
* reference
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean list(final String refName, final String mailboxName) throws IOException {
return doCommand(IMAPCommand.LIST, quoteMailboxName(refName) + " " + quoteMailboxName(mailboxName));
}
/**
* Login to the IMAP server with the given username and password. You must first connect to the server with
* {@link org.apache.commons.net.SocketClient#connect connect } before attempting to login. 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 username The account name being logged in to.
* @param password The plain text password of the account.
* @return True if the login attempt was successful, false if not.
* @throws IOException If a network I/O error occurs in the process of logging in.
*/
public boolean login(final String username, final String password) throws IOException {
if (getState() != IMAP.IMAPState.NOT_AUTH_STATE) {
return false;
}
if (!doCommand(IMAPCommand.LOGIN, username + " " + password)) {
return false;
}
setState(IMAP.IMAPState.AUTH_STATE);
return true;
}
// --------- commands available in the selected state
/**
* Send a LOGOUT command to the server. To fully disconnect from the server you must call disconnect(). A logout attempt is valid in any state. If the
* client is in the not authenticated or authenticated state, it enters the logout on a successful logout.
*
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean logout() throws IOException {
return doCommand(IMAPCommand.LOGOUT);
}
/**
* Send an LSUB command to the server. Quotes the parameters if necessary.
*
* @param refName The reference name.
* @param mailboxName The mailbox name.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean lsub(final String refName, final String mailboxName) throws IOException {
return doCommand(IMAPCommand.LSUB, quoteMailboxName(refName) + " " + quoteMailboxName(mailboxName));
}
/**
* Send a NOOP command to the server. This is useful for keeping a connection alive since most IMAP servers will timeout after 10 minutes of inactivity.
*
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean noop() throws IOException {
return doCommand(IMAPCommand.NOOP);
}
/**
* Send a RENAME command to the server.
*
* @param oldMailboxName The existing mailbox name to rename.
* @param newMailboxName The new mailbox name.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean rename(final String oldMailboxName, final String newMailboxName) throws IOException {
return doCommand(IMAPCommand.RENAME, quoteMailboxName(oldMailboxName) + " " + quoteMailboxName(newMailboxName));
}
/**
* Send a SEARCH command to the server.
*
* @param criteria The search criteria.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean search(final String criteria) throws IOException {
return search(null, criteria);
}
/**
* Send a SEARCH command to the server.
*
* @param charset The charset (optional).
* @param criteria The search criteria.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean search(final String charset, final String criteria) throws IOException {
String args = "";
if (charset != null) {
args += "CHARSET " + charset;
}
args += criteria;
return doCommand(IMAPCommand.SEARCH, args);
}
/**
* Send a SELECT command to the server.
*
* @param mailboxName The mailbox name to select.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean select(final String mailboxName) throws IOException {
return doCommand(IMAPCommand.SELECT, quoteMailboxName(mailboxName));
}
/**
* Send a STATUS command to the server.
*
* @param mailboxName The reference name.
* @param itemNames The status data item names.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean status(final String mailboxName, final String[] itemNames) throws IOException {
if (itemNames == null || itemNames.length < 1) {
throw new IllegalArgumentException("STATUS command requires at least one data item name");
}
final StringBuilder sb = new StringBuilder();
sb.append(quoteMailboxName(mailboxName));
sb.append(" (");
for (int i = 0; i < itemNames.length; i++) {
if (i > 0) {
sb.append(" ");
}
sb.append(itemNames[i]);
}
sb.append(")");
return doCommand(IMAPCommand.STATUS, sb.toString());
}
/**
* Send a STORE command to the server.
*
* @param sequenceSet The sequence set to update (e.g. 2:5)
* @param itemNames The item name for the STORE command (i.e. [+|-]FLAGS[.SILENT])
* @param itemValues The item values for the STORE command. (e.g. (\Deleted) )
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean store(final String sequenceSet, final String itemNames, final String itemValues) throws IOException {
return doCommand(IMAPCommand.STORE, sequenceSet + " " + itemNames + " " + itemValues);
}
/**
* Send a SUBSCRIBE command to the server.
*
* @param mailboxName The mailbox name to subscribe to.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean subscribe(final String mailboxName) throws IOException {
return doCommand(IMAPCommand.SUBSCRIBE, quoteMailboxName(mailboxName));
}
/**
* Send a UID command to the server.
*
* @param command The command for UID.
* @param commandArgs The arguments for the command.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean uid(final String command, final String commandArgs) throws IOException {
return doCommand(IMAPCommand.UID, command + " " + commandArgs);
}
/**
* Send a UNSUBSCRIBE command to the server.
*
* @param mailboxName The mailbox name to unsubscribe from.
* @return {@code true} if the command was successful,{@code false} if not.
* @throws IOException If a network I/O error occurs.
*/
public boolean unsubscribe(final String mailboxName) throws IOException {
return doCommand(IMAPCommand.UNSUBSCRIBE, quoteMailboxName(mailboxName));
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/imap/IMAPCommand.java 0000664 0000000 0000000 00000006151 14340477222 0031532 0 ustar 00root root 0000000 0000000 /*
* 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.imap;
/**
* IMAPCommand stores IMAP command codes.
*/
public enum IMAPCommand {
// These enums must either use the same name as the IMAP command
// or must provide the correct string as the parameter.
// Commands valid in any state:
CAPABILITY(0), NOOP(0), LOGOUT(0),
// Commands valid in Not Authenticated state
STARTTLS(0), AUTHENTICATE(1), LOGIN(2),
XOAUTH(1),
// commands valid in authenticated state
SELECT(1), EXAMINE(1), CREATE(1), DELETE(1), RENAME(2), SUBSCRIBE(1), UNSUBSCRIBE(1), LIST(2), LSUB(2), STATUS(2), // P2 = list in ()
APPEND(2, 4), // mbox [(flags)] [date-time] literal
// commands valid in selected state (substate of authenticated)
CHECK(0), CLOSE(0), EXPUNGE(0), SEARCH(1, Integer.MAX_VALUE), FETCH(2), STORE(3), COPY(2), UID(2, Integer.MAX_VALUE),;
/**
* Get the IMAP protocol string command corresponding to a command code.
*
* @param command the IMAPCommand whose command string is required.
* @return The IMAP protocol string command corresponding to a command code.
*/
public static final String getCommand(final IMAPCommand command) {
return command.getIMAPCommand();
}
private final String imapCommand;
@SuppressWarnings("unused") // not yet used
private final int minParamCount;
@SuppressWarnings("unused") // not yet used
private final int maxParamCount;
IMAPCommand() {
this(null);
}
IMAPCommand(final int paramCount) {
this(null, paramCount, paramCount);
}
IMAPCommand(final int minCount, final int maxCount) {
this(null, minCount, maxCount);
}
IMAPCommand(final String name) {
this(name, 0);
}
IMAPCommand(final String name, final int paramCount) {
this(name, paramCount, paramCount);
}
IMAPCommand(final String name, final int minCount, final int maxCount) {
this.imapCommand = name;
this.minParamCount = minCount;
this.maxParamCount = maxCount;
}
/**
* Get the IMAP protocol string command for this command
*
* @return The IMAP protocol string command corresponding to this command
*/
public String getIMAPCommand() {
return imapCommand != null ? imapCommand : name();
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/imap/IMAPReply.java 0000664 0000000 0000000 00000014230 14340477222 0031244 0 ustar 00root root 0000000 0000000 /*
* 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.imap;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.net.MalformedServerReplyException;
/**
* IMAPReply stores IMAP reply code constants.
*/
public final class IMAPReply {
/** The reply code indicating success of an operation. */
public static final int OK = 0;
/** The reply code indicating failure of an operation. */
public static final int NO = 1;
/** The reply code indicating command rejection. */
public static final int BAD = 2;
/** The reply code indicating command continuation. */
public static final int CONT = 3;
/**
* The reply code indicating a partial response. This is used when a chunk listener is registered and the listener requests that the reply lines are cleared
* on return.
*
* @since 3.4
*/
public static final int PARTIAL = 3;
/** The IMAP reply String indicating success of an operation. */
private static final String IMAP_OK = "OK";
/** The IMAP reply String indicating failure of an operation. */
private static final String IMAP_NO = "NO";
/** The IMAP reply String indicating command rejection. */
private static final String IMAP_BAD = "BAD";
// Start of line for untagged replies
private static final String IMAP_UNTAGGED_PREFIX = "* ";
// Start of line for continuation replies
private static final String IMAP_CONTINUATION_PREFIX = "+";
private static final String TAGGED_RESPONSE = "^\\w+ (\\S+).*"; // TODO perhaps be less strict on tag match?
// tag cannot contain: + ( ) { SP CTL % * " \ ]
private static final Pattern TAGGED_PATTERN = Pattern.compile(TAGGED_RESPONSE);
private static final String UNTAGGED_RESPONSE = "^\\* (\\S+).*";
private static final Pattern UNTAGGED_PATTERN = Pattern.compile(UNTAGGED_RESPONSE);
private static final Pattern LITERAL_PATTERN = Pattern.compile("\\{(\\d+)\\}$"); // {dd}
/**
* Intepret the String reply code - OK, NO, BAD - in a tagged response as a integer.
*
* @param line the tagged line to be checked
* @return {@link #OK} or {@link #NO} or {@link #BAD} or {@link #CONT}
* @throws IOException if the input has an unexpected format
*/
public static int getReplyCode(final String line) throws IOException {
return getReplyCode(line, TAGGED_PATTERN);
}
// Helper method to process both tagged and untagged replies.
private static int getReplyCode(final String line, final Pattern pattern) throws IOException {
if (isContinuation(line)) {
return CONT;
}
final Matcher m = pattern.matcher(line);
if (m.matches()) { // TODO would lookingAt() be more efficient? If so, then drop trailing .* from patterns
final String code = m.group(1);
if (code.equals(IMAP_OK)) {
return OK;
}
if (code.equals(IMAP_BAD)) {
return BAD;
}
if (code.equals(IMAP_NO)) {
return NO;
}
}
throw new MalformedServerReplyException("Received unexpected IMAP protocol response from server: '" + line + "'.");
}
/**
* Intepret the String reply code - OK, NO, BAD - in an untagged response as a integer.
*
* @param line the untagged line to be checked
* @return {@link #OK} or {@link #NO} or {@link #BAD} or {@link #CONT}
* @throws IOException if the input has an unexpected format
*/
public static int getUntaggedReplyCode(final String line) throws IOException {
return getReplyCode(line, UNTAGGED_PATTERN);
}
/**
* Checks if the reply line is a continuation, i.e. starts with "+"
*
* @param replyCode the code to be checked
* @return {@code true} if the response was a continuation
*/
public static boolean isContinuation(final int replyCode) {
return replyCode == CONT;
}
/**
* Checks if the reply line is a continuation, i.e. starts with "+"
*
* @param line the line to be checked
* @return {@code true} if the line is untagged
*/
public static boolean isContinuation(final String line) {
return line.startsWith(IMAP_CONTINUATION_PREFIX);
}
/**
* Checks whether the reply code indicates success or not
*
* @param replyCode the code to check
* @return {@code true} if the code equals {@link #OK}
*/
public static boolean isSuccess(final int replyCode) {
return replyCode == OK;
}
/**
* Checks if the reply line is untagged - e.g. "* OK ..."
*
* @param line to be checked
* @return {@code true} if the line is untagged
*/
public static boolean isUntagged(final String line) {
return line.startsWith(IMAP_UNTAGGED_PREFIX);
}
/**
* Checks if the line introduces a literal, i.e. ends with {dd}
*
* @param line the line to check
*
* @return the literal count, or -1 if there was no literal.
*/
public static int literalCount(final String line) {
final Matcher m = LITERAL_PATTERN.matcher(line);
if (m.find()) {
return Integer.parseInt(m.group(1)); // Should always parse because we matched \d+
}
return -1;
}
// Cannot be instantiated.
private IMAPReply() {
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/imap/IMAPSClient.java 0000664 0000000 0000000 00000030725 14340477222 0031521 0 ustar 00root root 0000000 0000000 /*
* 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.imap;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import org.apache.commons.net.io.CRLFLineReader;
import org.apache.commons.net.util.SSLContextUtils;
import org.apache.commons.net.util.SSLSocketUtils;
/**
* The IMAPSClient class provides SSL/TLS connection encryption to IMAPClient. Copied from
* FTPSClient and modified to suit
* IMAP. If implicit mode is selected (NOT the default), SSL/TLS negotiation starts right after the connection has been established. In explicit mode (the
* default), SSL/TLS negotiation starts when the user calls execTLS() and the server accepts the command.
*
*
* {@code
* //Implicit usage:
*
* IMAPSClient c = new IMAPSClient(true);
* c.connect("127.0.0.1", 993);
*
* //Explicit usage:
*
* IMAPSClient c = new IMAPSClient();
* c.connect("127.0.0.1", 143);
* if (c.execTLS()) { /rest of the commands here/ }
* }
*
*
* Warning: the hostname is not verified against the certificate by default, use {@link #setHostnameVerifier(HostnameVerifier)} or
* {@link #setEndpointCheckingEnabled(boolean)} (on Java 1.7+) to enable verification.
*/
public class IMAPSClient extends IMAPClient {
/** The default IMAP over SSL port. */
public static final int DEFAULT_IMAPS_PORT = 993;
/** Default secure socket protocol name. */
public static final String DEFAULT_PROTOCOL = "TLS";
/** The security mode. True - Implicit Mode / False - Explicit Mode. */
private final boolean isImplicit;
/** The secure socket protocol to be used, like SSL/TLS. */
private final String protocol;
/** The context object. */
private SSLContext context;
/**
* The cipher suites. SSLSockets have a default set of these anyway, so no initialization required.
*/
private String[] suites;
/** The protocol versions. */
private String[] protocols // null;
;// {"SSLv2", "SSLv3", "TLSv1", "TLSv1.1", "SSLv2Hello"};
/** The IMAPS {@link TrustManager} implementation, default null. */
private TrustManager trustManager;
/** The {@link KeyManager}, default null. */
private KeyManager keyManager;
/** The {@link HostnameVerifier} to use post-TLS, default null (i.e. no verification). */
private HostnameVerifier hostnameVerifier;
/** Use Java 1.7+ HTTPS Endpoint Identification Algorithim. */
private boolean tlsEndpointChecking;
/**
* Constructor for IMAPSClient. Sets security mode to explicit (isImplicit = false).
*/
public IMAPSClient() {
this(DEFAULT_PROTOCOL, false);
}
/**
* Constructor for IMAPSClient.
*
* @param implicit The security mode (Implicit/Explicit).
*/
public IMAPSClient(final boolean implicit) {
this(DEFAULT_PROTOCOL, implicit);
}
/**
* Constructor for IMAPSClient.
*
* @param implicit The security mode(Implicit/Explicit).
* @param ctx A pre-configured SSL Context.
*/
public IMAPSClient(final boolean implicit, final SSLContext ctx) {
this(DEFAULT_PROTOCOL, implicit, ctx);
}
/**
* Constructor for IMAPSClient.
*
* @param context A pre-configured SSL Context.
*/
public IMAPSClient(final SSLContext context) {
this(false, context);
}
/**
* Constructor for IMAPSClient.
*
* @param proto the protocol.
*/
public IMAPSClient(final String proto) {
this(proto, false);
}
/**
* Constructor for IMAPSClient.
*
* @param proto the protocol.
* @param implicit The security mode(Implicit/Explicit).
*/
public IMAPSClient(final String proto, final boolean implicit) {
this(proto, implicit, null);
}
/**
* Constructor for IMAPSClient.
*
* @param proto the protocol.
* @param implicit The security mode(Implicit/Explicit).
* @param ctx the SSL context
*/
public IMAPSClient(final String proto, final boolean implicit, final SSLContext ctx) {
setDefaultPort(DEFAULT_IMAPS_PORT);
protocol = proto;
isImplicit = implicit;
context = ctx;
}
/**
* Because there are so many connect() methods, the _connectAction_() method is provided as a means of performing some action immediately after establishing
* a connection, rather than reimplementing all of the connect() methods.
*
* @throws IOException If it is thrown by _connectAction_().
* @see org.apache.commons.net.SocketClient#_connectAction_()
*/
@Override
protected void _connectAction_() throws IOException {
// Implicit mode.
if (isImplicit) {
performSSLNegotiation();
}
super._connectAction_();
// Explicit mode - don't do anything. The user calls execTLS()
}
/**
* The TLS command execution.
*
* @throws SSLException If the server reply code is not positive.
* @throws IOException If an I/O error occurs while sending the command or performing the negotiation.
* @return TRUE if the command and negotiation succeeded.
*/
public boolean execTLS() throws SSLException, IOException {
if (sendCommand(IMAPCommand.getCommand(IMAPCommand.STARTTLS)) != IMAPReply.OK) {
return false;
// throw new SSLException(getReplyString());
}
performSSLNegotiation();
return true;
}
/**
* Returns the names of the cipher suites which could be enabled for use on this connection. When the underlying {@link java.net.Socket Socket} is not an
* {@link SSLSocket} instance, returns null.
*
* @return An array of cipher suite names, or null.
*/
public String[] getEnabledCipherSuites() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledCipherSuites();
}
return null;
}
/**
* Returns the names of the protocol versions which are currently enabled for use on this connection. When the underlying {@link java.net.Socket Socket} is
* not an {@link SSLSocket} instance, returns null.
*
* @return An array of protocols, or null.
*/
public String[] getEnabledProtocols() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledProtocols();
}
return null;
}
/**
* Get the currently configured {@link HostnameVerifier}.
*
* @return A HostnameVerifier instance.
* @since 3.4
*/
public HostnameVerifier getHostnameVerifier() {
return hostnameVerifier;
}
/**
* Get the {@link KeyManager} instance.
*
* @return The current {@link KeyManager} instance.
*/
private KeyManager getKeyManager() {
return keyManager;
}
/**
* Get the currently configured {@link TrustManager}.
*
* @return A TrustManager instance.
*/
public TrustManager getTrustManager() {
return trustManager;
}
/**
* Performs a lazy init of the SSL context.
*
* @throws IOException When could not initialize the SSL context.
*/
private void initSSLContext() throws IOException {
if (context == null) {
context = SSLContextUtils.createSSLContext(protocol, getKeyManager(), getTrustManager());
}
}
/**
* Return whether or not endpoint identification using the HTTPS algorithm on Java 1.7+ is enabled. The default behavior is for this to be disabled.
*
* @return True if enabled, false if not.
* @since 3.4
*/
public boolean isEndpointCheckingEnabled() {
return tlsEndpointChecking;
}
/**
* SSL/TLS negotiation. Acquires an SSL socket of a connection and carries out handshake processing.
*
* @throws IOException If server negotiation fails.
*/
private void performSSLNegotiation() throws IOException {
initSSLContext();
final SSLSocketFactory ssf = context.getSocketFactory();
final String host = _hostname_ != null ? _hostname_ : getRemoteAddress().getHostAddress();
final int port = getRemotePort();
final SSLSocket socket = (SSLSocket) ssf.createSocket(_socket_, host, port, true);
socket.setEnableSessionCreation(true);
socket.setUseClientMode(true);
if (tlsEndpointChecking) {
SSLSocketUtils.enableEndpointNameVerification(socket);
}
if (protocols != null) {
socket.setEnabledProtocols(protocols);
}
if (suites != null) {
socket.setEnabledCipherSuites(suites);
}
socket.startHandshake();
// TODO the following setup appears to duplicate that in the super class methods
_socket_ = socket;
_input_ = socket.getInputStream();
_output_ = socket.getOutputStream();
_reader = new CRLFLineReader(new InputStreamReader(_input_, __DEFAULT_ENCODING));
__writer = new BufferedWriter(new OutputStreamWriter(_output_, __DEFAULT_ENCODING));
if (hostnameVerifier != null && !hostnameVerifier.verify(host, socket.getSession())) {
throw new SSLHandshakeException("Hostname doesn't match certificate");
}
}
/**
* Controls which particular cipher suites are enabled for use on this connection. Called before server negotiation.
*
* @param cipherSuites The cipher suites.
*/
public void setEnabledCipherSuites(final String[] cipherSuites) {
suites = cipherSuites.clone();
}
/**
* Controls which particular protocol versions are enabled for use on this connection. I perform setting before a server negotiation.
*
* @param protocolVersions The protocol versions.
*/
public void setEnabledProtocols(final String[] protocolVersions) {
protocols = protocolVersions.clone();
}
/**
* Automatic endpoint identification checking using the HTTPS algorithm is supported on Java 1.7+. The default behavior is for this to be disabled.
*
* @param enable Enable automatic endpoint identification checking using the HTTPS algorithm on Java 1.7+.
* @since 3.4
*/
public void setEndpointCheckingEnabled(final boolean enable) {
tlsEndpointChecking = enable;
}
/**
* Override the default {@link HostnameVerifier} to use.
*
* @param newHostnameVerifier The HostnameVerifier implementation to set or null to disable.
* @since 3.4
*/
public void setHostnameVerifier(final HostnameVerifier newHostnameVerifier) {
hostnameVerifier = newHostnameVerifier;
}
/**
* Set a {@link KeyManager} to use.
*
* @param newKeyManager The KeyManager implementation to set.
* @see org.apache.commons.net.util.KeyManagerUtils
*/
public void setKeyManager(final KeyManager newKeyManager) {
keyManager = newKeyManager;
}
/**
* Override the default {@link TrustManager} to use.
*
* @param newTrustManager The TrustManager implementation to set.
* @see org.apache.commons.net.util.TrustManagerUtils
*/
public void setTrustManager(final TrustManager newTrustManager) {
trustManager = newTrustManager;
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/imap/package-info.java 0000664 0000000 0000000 00000001570 14340477222 0032031 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Basic IMAP and IMAPS support classes
*/
package org.apache.commons.net.imap; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/ 0000775 0000000 0000000 00000000000 14340477222 0026320 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/CRLFLineReader.java 0000664 0000000 0000000 00000004625 14340477222 0031653 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import org.apache.commons.net.util.NetConstants;
/**
* CRLFLineReader implements a readLine() method that requires exactly CRLF to terminate an input line. This is required for IMAP, which allows bare CR and LF.
*
* @since 3.0
*/
public final class CRLFLineReader extends BufferedReader {
private static final char LF = '\n';
private static final char CR = '\r';
/**
* Creates a CRLFLineReader that wraps an existing Reader input source.
*
* @param reader The Reader input source.
*/
public CRLFLineReader(final Reader reader) {
super(reader);
}
/**
* Read a line of text. A line is considered to be terminated by carriage return followed immediately by a linefeed. This contrasts with BufferedReader
* which also allows other combinations.
*
* @since 3.0
*/
@Override
public String readLine() throws IOException {
final StringBuilder sb = new StringBuilder();
int intch;
boolean prevWasCR = false;
synchronized (lock) { // make thread-safe (hopefully!)
while ((intch = read()) != NetConstants.EOS) {
if (prevWasCR && intch == LF) {
return sb.substring(0, sb.length() - 1);
}
prevWasCR = intch == CR;
sb.append((char) intch);
}
}
final String string = sb.toString();
if (string.isEmpty()) { // immediate EOF
return null;
}
return string;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/CopyStreamAdapter.java 0000664 0000000 0000000 00000010454 14340477222 0032556 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.util.EventListener;
import org.apache.commons.net.util.ListenerList;
/**
* The CopyStreamAdapter will relay CopyStreamEvents to a list of listeners when either of its bytesTransferred() methods are called. Its purpose is to
* facilitate the notification of the progress of a copy operation performed by one of the static copyStream() methods in org.apache.commons.io.Util to multiple
* listeners. The static copyStream() methods invoke the bytesTransfered(long, int) of a CopyStreamListener for performance reasons and also because multiple
* listeners cannot be registered given that the methods are static.
*
*
* @see CopyStreamEvent
* @see CopyStreamListener
* @see Util
*/
public class CopyStreamAdapter implements CopyStreamListener {
private final ListenerList internalListeners;
/**
* Creates a new copyStreamAdapter.
*/
public CopyStreamAdapter() {
internalListeners = new ListenerList();
}
/**
* Registers a CopyStreamListener to receive CopyStreamEvents. Although this method is not declared to be synchronized, it is implemented in a thread safe
* manner.
*
* @param listener The CopyStreamlistener to register.
*/
public void addCopyStreamListener(final CopyStreamListener listener) {
internalListeners.addListener(listener);
}
/**
* This method is invoked by a CopyStreamEvent source after copying a block of bytes from a stream. The CopyStreamEvent will contain the total number of
* bytes transferred so far and the number of bytes transferred in the last write. The CopyStreamAdapater will relay the event to all of its registered
* listeners, listing itself as the source of the event.
*
* @param event The CopyStreamEvent fired by the copying of a block of bytes.
*/
@Override
public void bytesTransferred(final CopyStreamEvent event) {
for (final EventListener listener : internalListeners) {
((CopyStreamListener) listener).bytesTransferred(event);
}
}
/**
* This method is not part of the JavaBeans model and is used by the static methods in the org.apache.commons.io.Util class for efficiency. It is invoked
* after a block of bytes to inform the listener of the transfer. The CopyStreamAdapater will create a CopyStreamEvent from the arguments and relay the
* event to all of its registered listeners, listing itself as the source of the event.
*
* @param totalBytesTransferred The total number of bytes transferred so far by the copy operation.
* @param bytesTransferred The number of bytes copied by the most recent write.
* @param streamSize The number of bytes in the stream being copied. This may be equal to CopyStreamEvent.UNKNOWN_STREAM_SIZE if the size is
* unknown.
*/
@Override
public void bytesTransferred(final long totalBytesTransferred, final int bytesTransferred, final long streamSize) {
for (final EventListener listener : internalListeners) {
((CopyStreamListener) listener).bytesTransferred(totalBytesTransferred, bytesTransferred, streamSize);
}
}
/**
* Unregisters a CopyStreamListener. Although this method is not synchronized, it is implemented in a thread safe manner.
*
* @param listener The CopyStreamlistener to unregister.
*/
public void removeCopyStreamListener(final CopyStreamListener listener) {
internalListeners.removeListener(listener);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/CopyStreamEvent.java 0000664 0000000 0000000 00000006637 14340477222 0032267 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.util.EventObject;
/**
* A CopyStreamEvent is triggered after every write performed by a stream copying operation. The event stores the number of bytes transferred by the write
* triggering the event as well as the total number of bytes transferred so far by the copy operation.
*
*
* @see CopyStreamListener
* @see CopyStreamAdapter
* @see Util
*/
public class CopyStreamEvent extends EventObject {
private static final long serialVersionUID = -964927635655051867L;
/**
* Constant used to indicate the stream size is unknown.
*/
public static final long UNKNOWN_STREAM_SIZE = -1;
private final int bytesTransferred;
private final long totalBytesTransferred;
private final long streamSize;
/**
* Creates a new CopyStreamEvent instance.
*
* @param source The source of the event.
* @param totalBytesTransferred The total number of bytes transferred so far during a copy operation.
* @param bytesTransferred The number of bytes transferred during the write that triggered the CopyStreamEvent.
* @param streamSize The number of bytes in the stream being copied. This may be set to UNKNOWN_STREAM_SIZE if the size is unknown.
*/
public CopyStreamEvent(final Object source, final long totalBytesTransferred, final int bytesTransferred, final long streamSize) {
super(source);
this.bytesTransferred = bytesTransferred;
this.totalBytesTransferred = totalBytesTransferred;
this.streamSize = streamSize;
}
/**
* Returns the number of bytes transferred by the write that triggered the event.
*
* @return The number of bytes transferred by the write that triggered the vent.
*/
public int getBytesTransferred() {
return bytesTransferred;
}
/**
* Returns the size of the stream being copied. This may be set to UNKNOWN_STREAM_SIZE if the size is unknown.
*
* @return The size of the stream being copied.
*/
public long getStreamSize() {
return streamSize;
}
/**
* Returns the total number of bytes transferred so far by the copy operation.
*
* @return The total number of bytes transferred so far by the copy operation.
*/
public long getTotalBytesTransferred() {
return totalBytesTransferred;
}
/**
* @since 3.0
*/
@Override
public String toString() {
return getClass().getName() + "[source=" + source + ", total=" + totalBytesTransferred + ", bytes=" + bytesTransferred + ", size=" + streamSize + "]";
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/CopyStreamException.java 0000664 0000000 0000000 00000005046 14340477222 0033135 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.io.IOException;
/**
* The CopyStreamException class is thrown by the org.apache.commons.io.Util copyStream() methods. It stores the number of bytes confirmed to have been
* transferred before an I/O error as well as the IOException responsible for the failure of a copy operation.
*
* @see Util
*/
public class CopyStreamException extends IOException {
private static final long serialVersionUID = -2602899129433221532L;
private final long totalBytesTransferred;
/**
* Creates a new CopyStreamException instance.
*
* @param message A message describing the error.
* @param bytesTransferred The total number of bytes transferred before an exception was thrown in a copy operation.
* @param exception The IOException thrown during a copy operation.
*/
public CopyStreamException(final String message, final long bytesTransferred, final IOException exception) {
super(message);
initCause(exception); // merge this into super() call once we need 1.6+
totalBytesTransferred = bytesTransferred;
}
/**
* Returns the IOException responsible for the failure of a copy operation.
*
* @return The IOException responsible for the failure of a copy operation.
*/
public IOException getIOException() {
return (IOException) getCause(); // cast is OK because it was initialized with an IOException
}
/**
* Returns the total number of bytes confirmed to have been transferred by a failed copy operation.
*
* @return The total number of bytes confirmed to have been transferred by a failed copy operation.
*/
public long getTotalBytesTransferred() {
return totalBytesTransferred;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/CopyStreamListener.java 0000664 0000000 0000000 00000005570 14340477222 0032766 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.util.EventListener;
/**
* The CopyStreamListener class can accept CopyStreamEvents to keep track of the progress of a stream copying operation. However, it is currently not used that
* way within NetComponents for performance reasons. Rather the bytesTransferred(long, int) method is called directly rather than passing an event to
* bytesTransferred(CopyStreamEvent), saving the creation of a CopyStreamEvent instance. Also, the only place where CopyStreamListener is currently used within
* NetComponents is in the static methods of the uninstantiable org.apache.commons.io.Util class, which would preclude the use of addCopyStreamListener and
* removeCopyStreamListener methods. However, future additions may use the JavaBean event model, which is why the hooks have been included from the beginning.
*
*
* @see CopyStreamEvent
* @see CopyStreamAdapter
* @see Util
*/
public interface CopyStreamListener extends EventListener {
/**
* This method is invoked by a CopyStreamEvent source after copying a block of bytes from a stream. The CopyStreamEvent will contain the total number of
* bytes transferred so far and the number of bytes transferred in the last write.
*
* @param event The CopyStreamEvent fired by the copying of a block of bytes.
*/
void bytesTransferred(CopyStreamEvent event);
/**
* This method is not part of the JavaBeans model and is used by the static methods in the org.apache.commons.io.Util class for efficiency. It is invoked
* after a block of bytes to inform the listener of the transfer.
*
* @param totalBytesTransferred The total number of bytes transferred so far by the copy operation.
* @param bytesTransferred The number of bytes copied by the most recent write.
* @param streamSize The number of bytes in the stream being copied. This may be equal to CopyStreamEvent.UNKNOWN_STREAM_SIZE if the size is
* unknown.
*/
void bytesTransferred(long totalBytesTransferred, int bytesTransferred, long streamSize);
}
DotTerminatedMessageReader.java 0000664 0000000 0000000 00000021557 14340477222 0034311 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io /*
* 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.io;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import org.apache.commons.net.util.NetConstants;
/**
* DotTerminatedMessageReader is a class used to read messages from a server that are terminated by a single dot followed by a <CR><LF> sequence and
* with double dots appearing at the begining of lines which do not signal end of message yet start with a dot. Various Internet protocols such as NNTP and POP3
* produce messages of this type.
* flush() will not flush the last byte written if that byte was a carriage return. A call to
* {@link #close close() }, however, will flush the carriage return.
*
*
*/
public final class FromNetASCIIOutputStream extends FilterOutputStream {
private boolean lastWasCR;
/**
* Creates a FromNetASCIIOutputStream instance that wraps an existing OutputStream.
*
* @param output The OutputStream to wrap.
*/
public FromNetASCIIOutputStream(final OutputStream output) {
super(output);
lastWasCR = false;
}
/**
* Closes the stream, writing all pending data.
*
* @throws IOException If an error occurs while closing the stream.
*/
@Override
public synchronized void close() throws IOException {
if (FromNetASCIIInputStream._noConversionRequired) {
super.close();
return;
}
if (lastWasCR) {
out.write('\r');
}
super.close();
}
/**
* Writes a byte array to the stream.
*
* @param buffer The byte array to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public synchronized void write(final byte buffer[]) throws IOException {
write(buffer, 0, buffer.length);
}
/**
* Writes a number of bytes from a byte array to the stream starting from a given offset.
*
* @param buffer The byte array to write.
* @param offset The offset into the array at which to start copying data.
* @param length The number of bytes to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public synchronized void write(final byte buffer[], int offset, int length) throws IOException {
if (FromNetASCIIInputStream._noConversionRequired) {
// FilterOutputStream method is very slow.
// super.write(buffer, offset, length);
out.write(buffer, offset, length);
return;
}
while (length-- > 0) {
writeInt(buffer[offset++]);
}
}
/**
* Writes a byte to the stream. Note that a call to this method might not actually write a byte to the underlying stream until a subsequent character is
* written, from which it can be determined if a NETASCII line separator was encountered. This is transparent to the programmer and is only mentioned for
* completeness.
*
* @param ch The byte to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public synchronized void write(final int ch) throws IOException {
if (FromNetASCIIInputStream._noConversionRequired) {
out.write(ch);
return;
}
writeInt(ch);
}
private void writeInt(final int ch) throws IOException {
switch (ch) {
case '\r':
lastWasCR = true;
// Don't write anything. We need to see if next one is linefeed
break;
case '\n':
if (lastWasCR) {
out.write(FromNetASCIIInputStream._lineSeparatorBytes);
lastWasCR = false;
break;
}
out.write('\n');
break;
default:
if (lastWasCR) {
out.write('\r');
lastWasCR = false;
}
out.write(ch);
break;
}
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/SocketInputStream.java 0000664 0000000 0000000 00000004177 14340477222 0032620 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
/**
* This class wraps an input stream, storing a reference to its originating socket. When the stream is closed, it will also close the socket immediately
* afterward. This class is useful for situations where you are dealing with a stream originating from a socket, but do not have a reference to the socket, and
* want to make sure it closes when the stream closes.
*
* @see SocketOutputStream
*/
public class SocketInputStream extends FilterInputStream {
private final Socket socket;
/**
* Creates a SocketInputStream instance wrapping an input stream and storing a reference to a socket that should be closed on closing the stream.
*
* @param socket The socket to close on closing the stream.
* @param stream The input stream to wrap.
*/
public SocketInputStream(final Socket socket, final InputStream stream) {
super(stream);
this.socket = socket;
}
/**
* Closes the stream and immediately afterward closes the referenced socket.
*
* @throws IOException If there is an error in closing the stream or socket.
*/
@Override
public void close() throws IOException {
super.close();
socket.close();
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/SocketOutputStream.java 0000664 0000000 0000000 00000005465 14340477222 0033022 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
/**
* This class wraps an output stream, storing a reference to its originating socket. When the stream is closed, it will also close the socket immediately
* afterward. This class is useful for situations where you are dealing with a stream originating from a socket, but do not have a reference to the socket, and
* want to make sure it closes when the stream closes.
*
*
* @see SocketInputStream
*/
public class SocketOutputStream extends FilterOutputStream {
private final Socket socket;
/**
* Creates a SocketOutputStream instance wrapping an output stream and storing a reference to a socket that should be closed on closing the stream.
*
* @param socket The socket to close on closing the stream.
* @param stream The input stream to wrap.
*/
public SocketOutputStream(final Socket socket, final OutputStream stream) {
super(stream);
this.socket = socket;
}
/**
* Closes the stream and immediately afterward closes the referenced socket.
*
* @throws IOException If there is an error in closing the stream or socket.
*/
@Override
public void close() throws IOException {
super.close();
socket.close();
}
/**
* Writes a number of bytes from a byte array to the stream starting from a given offset. This method bypasses the equivalent method in FilterOutputStream
* because the FilterOutputStream implementation is very inefficient.
*
* @param buffer The byte array to write.
* @param offset The offset into the array at which to start copying data.
* @param length The number of bytes to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public void write(final byte buffer[], final int offset, final int length) throws IOException {
out.write(buffer, offset, length);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/ToNetASCIIInputStream.java0000664 0000000 0000000 00000011712 14340477222 0033163 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.net.util.NetConstants;
/**
* This class wraps an input stream, replacing all singly occurring <LF> (linefeed) characters with <CR><LF> (carriage return followed by
* linefeed), which is the NETASCII standard for representing a newline. You would use this class to implement ASCII file transfers requiring conversion to
* NETASCII.
*
*
*/
public final class ToNetASCIIInputStream extends FilterInputStream {
private static final int NOTHING_SPECIAL = 0;
private static final int LAST_WAS_CR = 1;
private static final int LAST_WAS_NL = 2;
private int status;
/**
* Creates a ToNetASCIIInputStream instance that wraps an existing InputStream.
*
* @param input The InputStream to wrap.
*/
public ToNetASCIIInputStream(final InputStream input) {
super(input);
status = NOTHING_SPECIAL;
}
@Override
public int available() throws IOException {
final int result;
result = in.available();
if (status == LAST_WAS_NL) {
return result + 1;
}
return result;
}
/** Returns false. Mark is not supported. */
@Override
public boolean markSupported() {
return false;
}
/**
* Reads and returns the next byte in the stream. If the end of the message has been reached, returns -1.
*
* @return The next character in the stream. Returns -1 if the end of the stream has been reached.
* @throws IOException If an error occurs while reading the underlying stream.
*/
@Override
public int read() throws IOException {
final int ch;
if (status == LAST_WAS_NL) {
status = NOTHING_SPECIAL;
return '\n';
}
ch = in.read();
switch (ch) {
case '\r':
status = LAST_WAS_CR;
return '\r';
case '\n':
if (status != LAST_WAS_CR) {
status = LAST_WAS_NL;
return '\r';
}
//$FALL-THROUGH$
default:
status = NOTHING_SPECIAL;
return ch;
}
// statement not reached
// return ch;
}
/**
* Reads the next number of bytes from the stream into an array and returns the number of bytes read. Returns -1 if the end of the stream has been reached.
*
* @param buffer The byte array in which to store the data.
* @return The number of bytes read. Returns -1 if the end of the message has been reached.
* @throws IOException If an error occurs in reading the underlying stream.
*/
@Override
public int read(final byte[] buffer) throws IOException {
return read(buffer, 0, buffer.length);
}
/**
* Reads the next number of bytes from the stream into an array and returns the number of bytes read. Returns -1 if the end of the message has been reached.
* The characters are stored in the array starting from the given offset and up to the length specified.
*
* @param buffer The byte array in which to store the data.
* @param offset The offset into the array at which to start storing data.
* @param length The number of bytes to read.
* @return The number of bytes read. Returns -1 if the end of the stream has been reached.
* @throws IOException If an error occurs while reading the underlying stream.
*/
@Override
public int read(final byte[] buffer, int offset, int length) throws IOException {
int ch;
final int off;
if (length < 1) {
return 0;
}
ch = available();
if (length > ch) {
length = ch;
}
// If nothing is available, block to read only one character
if (length < 1) {
length = 1;
}
if ((ch = read()) == NetConstants.EOS) {
return NetConstants.EOS;
}
off = offset;
do {
buffer[offset++] = (byte) ch;
} while (--length > 0 && (ch = read()) != NetConstants.EOS);
return offset - off;
}
}
ToNetASCIIOutputStream.java 0000664 0000000 0000000 00000006526 14340477222 0033314 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io /*
* 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.io;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* This class wraps an output stream, replacing all singly occurring <LF> (linefeed) characters with <CR><LF> (carriage return followed by
* linefeed), which is the NETASCII standard for representing a newline. You would use this class to implement ASCII file transfers requiring conversion to
* NETASCII.
*
*
*/
public final class ToNetASCIIOutputStream extends FilterOutputStream {
private boolean lastWasCR;
/**
* Creates a ToNetASCIIOutputStream instance that wraps an existing OutputStream.
*
* @param output The OutputStream to wrap.
*/
public ToNetASCIIOutputStream(final OutputStream output) {
super(output);
lastWasCR = false;
}
/**
* Writes a byte array to the stream.
*
* @param buffer The byte array to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public synchronized void write(final byte buffer[]) throws IOException {
write(buffer, 0, buffer.length);
}
/**
* Writes a number of bytes from a byte array to the stream starting from a given offset.
*
* @param buffer The byte array to write.
* @param offset The offset into the array at which to start copying data.
* @param length The number of bytes to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public synchronized void write(final byte buffer[], int offset, int length) throws IOException {
while (length-- > 0) {
write(buffer[offset++]);
}
}
/**
* Writes a byte to the stream. Note that a call to this method may result in multiple writes to the underlying input stream in order to convert naked
* newlines to NETASCII line separators. This is transparent to the programmer and is only mentioned for completeness.
*
* @param ch The byte to write.
* @throws IOException If an error occurs while writing to the underlying stream.
*/
@Override
public synchronized void write(final int ch) throws IOException {
switch (ch) {
case '\r':
lastWasCR = true;
out.write('\r');
return;
case '\n':
if (!lastWasCR) {
out.write('\r');
}
//$FALL-THROUGH$
default:
lastWasCR = false;
out.write(ch);
}
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/io/Util.java 0000664 0000000 0000000 00000036737 14340477222 0030120 0 ustar 00root root 0000000 0000000 /*
* 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.io;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.Socket;
import org.apache.commons.net.util.NetConstants;
/**
* The Util class cannot be instantiated and stores short static convenience methods that are often quite useful.
*
*
* @see CopyStreamException
* @see CopyStreamListener
* @see CopyStreamAdapter
*/
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
* a zero or negative buffer size is supplied.
*/
public static final int DEFAULT_COPY_BUFFER_SIZE = 1024;
/**
* Closes the object quietly, catching rather than throwing IOException. Intended for use from finally blocks.
*
* @param closeable the object to close, may be {@code null}
* @since 3.0
*/
public static void closeQuietly(final Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (final IOException e) {
// Ignored
}
}
}
/**
* Closes the socket quietly, catching rather than throwing IOException. Intended for use from finally blocks.
*
* @param socket the socket to close, may be {@code null}
* @since 3.0
*/
public static void closeQuietly(final Socket socket) {
if (socket != null) {
try {
socket.close();
} catch (final IOException e) {
// Ignored
}
}
}
/**
* Same as copyReader(source, dest, DEFAULT_COPY_BUFFER_SIZE);
*
* @param source where to copy from
* @param dest where to copy to
* @return number of bytes copied
* @throws CopyStreamException on error
*/
public static long copyReader(final Reader source, final Writer dest) throws CopyStreamException {
return copyReader(source, dest, DEFAULT_COPY_BUFFER_SIZE);
}
/**
* Copies the contents of a Reader to a Writer using a copy buffer of a given size. The contents of the Reader are read until its end is reached, but
* neither the source nor the destination are closed. You must do this yourself outside of the method call. The number of characters read/written is
* returned.
*
* @param source The source Reader.
* @param dest The destination writer.
* @param bufferSize The number of characters to buffer during the copy. A zero or negative value means to use {@link #DEFAULT_COPY_BUFFER_SIZE}.
* @return The number of characters read/written in the copy operation.
* @throws CopyStreamException If an error occurs while reading from the source or writing to the destination. The CopyStreamException will contain the
* number of bytes confirmed to have been transferred before an IOException occurred, and it will also contain the IOException
* that caused the error. These values can be retrieved with the CopyStreamException getTotalBytesTransferred() and
* getIOException() methods.
*/
public static long copyReader(final Reader source, final Writer dest, final int bufferSize) throws CopyStreamException {
return copyReader(source, dest, bufferSize, CopyStreamEvent.UNKNOWN_STREAM_SIZE, null);
}
/**
* Copies the contents of a Reader to a Writer using a copy buffer of a given size and notifies the provided CopyStreamListener of the progress of the copy
* operation by calling its bytesTransferred(long, int) method after each write to the destination. If you wish to notify more than one listener you should
* use a CopyStreamAdapter as the listener and register the additional listeners with the CopyStreamAdapter.
* copyStream(source, dest, DEFAULT_COPY_BUFFER_SIZE);
*
* @param source where to copy from
* @param dest where to copy to
* @return number of bytes copied
* @throws CopyStreamException on error
*/
public static long copyStream(final InputStream source, final OutputStream dest) throws CopyStreamException {
return copyStream(source, dest, DEFAULT_COPY_BUFFER_SIZE);
}
/**
* Copies the contents of an InputStream to an OutputStream using a copy buffer of a given size. The contents of the InputStream are read until the end of
* the stream is reached, but neither the source nor the destination are closed. You must do this yourself outside of the method call. The number of bytes
* read/written is returned.
*
* @param source The source InputStream.
* @param dest The destination OutputStream.
* @param bufferSize The number of bytes to buffer during the copy. A zero or negative value means to use {@link #DEFAULT_COPY_BUFFER_SIZE}.
* @return The number of bytes read/written in the copy operation.
* @throws CopyStreamException If an error occurs while reading from the source or writing to the destination. The CopyStreamException will contain the
* number of bytes confirmed to have been transferred before an IOException occurred, and it will also contain the IOException
* that caused the error. These values can be retrieved with the CopyStreamException getTotalBytesTransferred() and
* getIOException() methods.
*/
public static long copyStream(final InputStream source, final OutputStream dest, final int bufferSize) throws CopyStreamException {
return copyStream(source, dest, bufferSize, CopyStreamEvent.UNKNOWN_STREAM_SIZE, null);
}
/**
* Copies the contents of an InputStream to an OutputStream using a copy buffer of a given size and notifies the provided CopyStreamListener of the progress
* of the copy operation by calling its bytesTransferred(long, int) method after each write to the destination. If you wish to notify more than one listener
* you should use a CopyStreamAdapter as the listener and register the additional listeners with the CopyStreamAdapter.
* NNTPConectionClosedException is
* a subclass of 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 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 }.
* DEFAULT_PORT 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.
* connect is of type void.
* NNTPConectionClosedException is
* a subclass of 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 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 }.
*
* writer = client.postArticle();
* if (writer == null) // failure
* return false;
* header = new SimpleNNTPHeader("foobar@foo.com", "Just testing");
* header.addNewsgroup("alt.test");
* writer.write(header.toString());
* writer.write("This is just a test");
* writer.close();
* if (!client.completePendingCommand()) // failure
* return false;
*
* retrieveArticle((String) null) Note: the return can be cast to a {@link BufferedReader}
*
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @throws IOException if an IO error occurs
*/
public Reader retrieveArticle() throws IOException {
return retrieveArticle((String) null);
}
/**
* @param articleNumber The number of the the article to retrieve
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @throws IOException on error
* @deprecated 3.0 use {@link #retrieveArticle(long)} instead
*/
@Deprecated
public Reader retrieveArticle(final int articleNumber) throws IOException {
return retrieveArticle((long) articleNumber);
}
/**
* @param articleNumber The number of the the article to retrieve.
* @param pointer A parameter through which to return the article's number and unique id
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @throws IOException on error
* @deprecated 3.0 use {@link #retrieveArticle(long, ArticleInfo)} instead
*/
@Deprecated
public Reader retrieveArticle(final int articleNumber, final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final Reader rdr = retrieveArticle(articleNumber, ai);
ai2ap(ai, pointer);
return rdr;
}
/**
* Same as retrieveArticle(articleNumber, null)
*
* @param articleNumber the article number to fetch
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @throws IOException if an IO error occurs
*/
public BufferedReader retrieveArticle(final long articleNumber) throws IOException {
return retrieveArticle(articleNumber, null);
}
/**
* Retrieves an article from the currently selected newsgroup. The article is referenced by its article number. The article number and identifier contained
* in the server reply are returned through an ArticleInfo. The articleId field of the ArticleInfo cannot always be trusted because some NNTP
* servers do not correctly follow the RFC 977 reply format.
* retrieveArticle(articleId, (ArticleInfo) null) Note: the return can be cast to a {@link BufferedReader}
*
* @param articleId the article id to retrieve
* @return A DotTerminatedMessageReader instance from which the article can be read. null if the article does not exist.
* @throws IOException if an IO error occurs
*/
public Reader retrieveArticle(final String articleId) throws IOException {
return retrieveArticle(articleId, (ArticleInfo) null);
}
/**
* Retrieves an article from the NNTP server. The article is referenced by its unique article identifier (including the enclosing < and >). The
* article number and identifier contained in the server reply are returned through an ArticleInfo. The articleId field of the ArticleInfo
* cannot always be trusted because some NNTP servers do not correctly follow the RFC 977 reply format.
* retrieveArticleBody(null) Note: the return can be cast to a {@link BufferedReader}
*
* @return A DotTerminatedMessageReader instance from which the article body can be read. null if the article does not exist.
* @throws IOException if an error occurs
*/
public Reader retrieveArticleBody() throws IOException {
return retrieveArticleBody(null);
}
/**
* @param a tba
* @return tba
* @throws IOException tba
* @deprecated 3.0 use {@link #retrieveArticleBody(long)} instead
*/
@Deprecated
public Reader retrieveArticleBody(final int a) throws IOException {
return retrieveArticleBody((long) a);
}
/**
* @param a tba
* @param ap tba
* @return tba
* @throws IOException tba
* @deprecated 3.0 use {@link #retrieveArticleBody(long, ArticleInfo)} instead
*/
@Deprecated
public Reader retrieveArticleBody(final int a, final ArticlePointer ap) throws IOException {
final ArticleInfo ai = ap2ai(ap);
final Reader rdr = retrieveArticleBody(a, ai);
ai2ap(ai, ap);
return rdr;
}
/**
* Same as retrieveArticleBody(articleNumber, null)
*
* @param articleNumber the article number
* @return the reader
* @throws IOException if an error occurs
*/
public BufferedReader retrieveArticleBody(final long articleNumber) throws IOException {
return retrieveArticleBody(articleNumber, null);
}
/**
* Retrieves an article body from the currently selected newsgroup. The article is referenced by its article number. The article number and identifier
* contained in the server reply are returned through an ArticleInfo. The articleId field of the ArticleInfo cannot always be trusted because
* some NNTP servers do not correctly follow the RFC 977 reply format.
* retrieveArticleBody(articleId, (ArticleInfo) null) Note: the return can be cast to a {@link BufferedReader}
*
* @param articleId the article id
* @return A DotTerminatedMessageReader instance from which the article body can be read. null if the article does not exist.
* @throws IOException if an error occurs
*/
public Reader retrieveArticleBody(final String articleId) throws IOException {
return retrieveArticleBody(articleId, (ArticleInfo) null);
}
/**
* Retrieves an article body from the NNTP server. The article is referenced by its unique article identifier (including the enclosing < and >). The
* article number and identifier contained in the server reply are returned through an ArticleInfo. The articleId field of the ArticleInfo
* cannot always be trusted because some NNTP servers do not correctly follow the RFC 977 reply format.
* retrieveArticleHeader((String) null) Note: the return can be cast to a {@link BufferedReader}
*
* @return the reader
* @throws IOException if an error occurs
*/
public Reader retrieveArticleHeader() throws IOException {
return retrieveArticleHeader((String) null);
}
/**
* @param a tba
* @return tba
* @throws IOException tba
* @deprecated 3.0 use {@link #retrieveArticleHeader(long)} instead
*/
@Deprecated
public Reader retrieveArticleHeader(final int a) throws IOException {
return retrieveArticleHeader((long) a);
}
/**
* @param a tba
* @param ap tba
* @return tba
* @throws IOException tba
* @deprecated 3.0 use {@link #retrieveArticleHeader(long, ArticleInfo)} instead
*/
@Deprecated
public Reader retrieveArticleHeader(final int a, final ArticlePointer ap) throws IOException {
final ArticleInfo ai = ap2ai(ap);
final Reader rdr = retrieveArticleHeader(a, ai);
ai2ap(ai, ap);
return rdr;
}
/**
* Same as retrieveArticleHeader(articleNumber, null)
*
* @param articleNumber the article number
* @return the reader
* @throws IOException if an error occurs
*/
public BufferedReader retrieveArticleHeader(final long articleNumber) throws IOException {
return retrieveArticleHeader(articleNumber, null);
}
/**
* Retrieves an article header from the currently selected newsgroup. The article is referenced by its article number. The article number and identifier
* contained in the server reply are returned through an ArticleInfo. The articleId field of the ArticleInfo cannot always be trusted because
* some NNTP servers do not correctly follow the RFC 977 reply format.
* retrieveArticleHeader(articleId, (ArticleInfo) null) Note: the return can be cast to a {@link BufferedReader}
*
* @param articleId the article id to fetch
* @return the reader
* @throws IOException if an error occurs
*/
public Reader retrieveArticleHeader(final String articleId) throws IOException {
return retrieveArticleHeader(articleId, (ArticleInfo) null);
}
/**
* Retrieves an article header from the NNTP server. The article is referenced by its unique article identifier (including the enclosing < and >). The
* article number and identifier contained in the server reply are returned through an ArticleInfo. The articleId field of the ArticleInfo
* cannot always be trusted because some NNTP servers do not correctly follow the RFC 977 reply format.
* selectArticle((String) null, articleId) . Useful for retrieving the current article number.
*
* @param pointer to the article
* @return true if OK
* @throws IOException on error
*/
public boolean selectArticle(final ArticleInfo pointer) throws IOException {
return selectArticle(null, pointer);
}
/**
* @param pointer A parameter through which to return the article's number and unique id
* @return True if successful, false if not.
* @throws IOException on error
* @deprecated 3.0 use {@link #selectArticle(ArticleInfo)} instead
*/
@Deprecated
public boolean selectArticle(final ArticlePointer pointer) throws IOException {
final ArticleInfo ai = ap2ai(pointer);
final boolean b = selectArticle(ai);
ai2ap(ai, pointer);
return b;
}
/**
* @param a tba
* @return tba
* @throws IOException tba
* @deprecated 3.0 use {@link #selectArticle(long)} instead
*/
@Deprecated
public boolean selectArticle(final int a) throws IOException {
return selectArticle((long) a);
}
/**
* @param a tba
* @param ap tba
* @return tba
* @throws IOException tba
* @deprecated 3.0 use {@link #selectArticle(long, ArticleInfo)} instead
*/
@Deprecated
public boolean selectArticle(final int a, final ArticlePointer ap) throws IOException {
final ArticleInfo ai = ap2ai(ap);
final boolean b = selectArticle(a, ai);
ai2ap(ai, ap);
return b;
}
/**
* Same as selectArticle(articleNumber, null)
*
* @param articleNumber the numger
* @return true if successful
* @throws IOException on error
*/
public boolean selectArticle(final long articleNumber) throws IOException {
return selectArticle(articleNumber, null);
}
/**
* Select an article in the currently selected newsgroup by its number. and return its article number and id through the pointer parameter. This is achieved
* through the STAT command. According to RFC 977, this WILL set the current article pointer on the server. Use this command to select an article before
* retrieving it, or to obtain an article's unique identifier given its number.
* selectArticle(articleId, (ArticleInfo) null)
*
* @param articleId the article Id
* @return true if successful
* @throws IOException on error
*/
public boolean selectArticle(final String articleId) throws IOException {
return selectArticle(articleId, (ArticleInfo) null);
}
/**
* Select an article by its unique identifier (including enclosing < and >) and return its article number and id through the pointer parameter. This
* is achieved through the STAT command. According to RFC 977, this will NOT set the current article pointer on the server. To do that, you must reference
* the article by its number.
* selectNewsgroup(newsgroup, null)
*
* @param newsgroup the newsgroup name
* @return true if newsgroup exist and was selected
* @throws IOException if an error occurs
*/
public boolean selectNewsgroup(final String newsgroup) throws IOException {
return selectNewsgroup(newsgroup, null);
}
/**
* Select the specified newsgroup to be the target of for future article retrieval and posting operations. Also return the newsgroup information contained
* in the server reply through the info parameter.
* selectNextArticle((ArticleInfo) null)
*
* @return true if successful
* @throws IOException on error
*/
public boolean selectNextArticle() throws IOException {
return selectNextArticle((ArticleInfo) null);
}
/**
* Select the article following the currently selected article in the currently selected newsgroup and return its number and unique id through the pointer
* parameter. Because of deviating server implementations, the articleId information cannot be trusted. To obtain the article identifier, issue a
* selectArticle(pointer.articleNumber, pointer) immediately afterward.
* selectPreviousArticle((ArticleInfo) null)
*
* @return true if successful
* @throws IOException on error
*/
public boolean selectPreviousArticle() throws IOException {
return selectPreviousArticle((ArticleInfo) null);
}
// Helper methods
/**
* Select the article preceeding the currently selected article in the currently selected newsgroup and return its number and unique id through the pointer
* parameter. Because of deviating server implementations, the articleId information cannot be trusted. To obtain the article identifier, issue a
* selectArticle(pointer.articleNumber, pointer) immediately afterward.
*
* query = new NewsGroupsOrNewsQuery(new GregorianCalendar(97, 11, 15), false);
* query.addDistribution("comp");
* NewsgroupInfo[] newsgroups = client.listNewgroups(query);
*
*
* This will retrieve the list of newsgroups starting with the comp. distribution prefix created since midnight 11/15/97.
*
* @see NNTPClient
*/
public final class NewGroupsOrNewsQuery {
private final String date, time;
private StringBuffer distributions;
private StringBuffer newsgroups;
private final boolean isGMT;
/**
* Creates a new query using the given time as a reference point.
* * wildcard, as in comp.lang.* or comp.lang.java.* . Adding at least one newsgroup is mandatory for
* the NEWNEWS command.
* * wildcard, as in comp.lang.* or
* comp.lang.java.* .
*
* query.addNewsgroup("comp.lang.java.*");
* query.omitNewsgroup("comp.lang.java.advocacy");
*
* POSTING_PERMISSION constants.
*
* writer = client.postArticle();
* if (writer == null) // failure
* return false;
* header = new SimpleNNTPHeader("foobar@foo.com", "Just testing");
* header.addNewsgroup("alt.test");
* header.addHeaderField("Organization", "Foobar, Inc.");
* writer.write(header.toString());
* writer.write("This is just a test");
* writer.close();
* if (!client.completePendingCommand()) // failure
* return false;
*
*
* @see NNTPClient
*/
public class SimpleNNTPHeader {
private final String subject, from;
private final StringBuilder newsgroups;
private final StringBuilder headerFields;
private int newsgroupCount;
/**
* Creates a new SimpleNNTPHeader instance initialized with the given from and subject header field values.
* From: header field. This should be the article poster's email address.
* @param subject The value of the Subject: header field. This should be the subject of the article.
*/
public SimpleNNTPHeader(final String from, final String subject) {
this.from = from;
this.subject = subject;
this.newsgroups = new StringBuilder();
this.headerFields = new StringBuilder();
this.newsgroupCount = 0;
}
/**
* Adds an arbitrary header field with the given value to the article header. These headers will be written after the From, Newsgroups, and Subject fields
* when the SimpleNNTPHeader is convertered to a string. An example use would be:
*
*
* header.addHeaderField("Organization", "Foobar, Inc.");
*
* Newsgroups: field.
* From: header field.
* Newsgroups: header field.
* Subject: header field.
* true if and only if the argument is not null and is a
* NtpV3Impl object that contains the same values as this object.
*
* @param obj the object to compare with.
* @return true if the objects are the same; false otherwise.
* @since 3.4
*/
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
final NtpV3Impl other = (NtpV3Impl) obj;
return java.util.Arrays.equals(buf, other.buf);
}
/**
* Returns the datagram packet with the NTP details already filled in.
*
* @return a datagram packet.
*/
@Override
public synchronized DatagramPacket getDatagramPacket() {
if (dp == null) {
dp = new DatagramPacket(buf, buf.length);
dp.setPort(NTP_PORT);
}
return dp;
}
/**
* @return 4 bytes as 32-bit int
*/
private int getInt(final int index) {
final int i = ui(buf[index]) << 24 | ui(buf[index + 1]) << 16 | ui(buf[index + 2]) << 8 | ui(buf[index + 3]);
return i;
}
/**
* Returns leap indicator as defined in RFC-1305 which is a two-bit code: 0=no warning 1=last minute has 61 seconds 2=last minute has 59 seconds 3=alarm
* condition (clock not synchronized)
*
* @return leap indicator as defined in RFC-1305.
*/
@Override
public int getLeapIndicator() {
return (ui(buf[LI_INDEX]) >> LI_SHIFT) & 0x3;
}
/**
* Get Long value represented by bits starting at specified index.
*
* @return 8 bytes as 64-bit long
*/
private long getLong(final int index) {
final long i = ul(buf[index]) << 56 | ul(buf[index + 1]) << 48 | ul(buf[index + 2]) << 40 | ul(buf[index + 3]) << 32 | ul(buf[index + 4]) << 24
| ul(buf[index + 5]) << 16 | ul(buf[index + 6]) << 8 | ul(buf[index + 7]);
return i;
}
/**
* Returns mode as defined in RFC-1305 which is a 3-bit integer whose value is indicated by the MODE_xxx parameters.
*
* @return mode as defined in RFC-1305.
*/
@Override
public int getMode() {
return (ui(buf[MODE_INDEX]) >> MODE_SHIFT) & 0x7;
}
/**
* Return human-readable name of message mode type as described in RFC 1305.
*
* @return mode name as string.
*/
@Override
public String getModeName() {
return NtpUtils.getModeName(getMode());
}
/**
* Returns the originate time as defined in RFC-1305.
*
* @return the originate time. Never returns null.
*/
@Override
public TimeStamp getOriginateTimeStamp() {
return getTimestamp(ORIGINATE_TIMESTAMP_INDEX);
}
/**
* Returns poll interval as defined in RFC-1305, which is an eight-bit signed integer indicating the maximum interval between successive messages, in
* seconds to the nearest power of two (e.g. value of six indicates an interval of 64 seconds. The values that can appear in this field range from
* NTP_MINPOLL to NTP_MAXPOLL inclusive.
*
* @return poll interval as defined in RFC-1305.
*/
@Override
public int getPoll() {
return buf[POLL_INDEX];
}
/**
* Returns precision as defined in RFC-1305 encoded as an 8-bit signed integer (seconds to nearest power of two). Values normally range from -6 to -20.
*
* @return precision as defined in RFC-1305.
*/
@Override
public int getPrecision() {
return buf[PRECISION_INDEX];
}
/**
* Returns receive timestamp as defined in RFC-1305.
*
* @return the receive time. Never returns null.
*/
@Override
public TimeStamp getReceiveTimeStamp() {
return getTimestamp(RECEIVE_TIMESTAMP_INDEX);
}
/**
* Returns the reference id as defined in RFC-1305, which is a 32-bit integer whose value is dependent on several criteria.
*
* @return the reference id as defined in RFC-1305.
*/
@Override
public int getReferenceId() {
return getInt(REFERENCE_ID_INDEX);
}
/**
* Returns the reference id string. String cannot be null but value is dependent on the version of the NTP spec supported and stratum level. Value can be an
* empty string, clock type string, IP address, or a hex string.
*
* @return the reference id string.
*/
@Override
public String getReferenceIdString() {
final int version = getVersion();
final int stratum = getStratum();
if (version == VERSION_3 || version == VERSION_4) {
if (stratum == 0 || stratum == 1) {
return idAsString(); // 4-character ASCII string (e.g. GPS, USNO)
}
// in NTPv4 servers this is latest transmit timestamp of ref source
if (version == VERSION_4) {
return idAsHex();
}
}
// Stratum 2 and higher this is a four-octet IPv4 address
// of the primary reference host.
if (stratum >= 2) {
return idAsIPAddress();
}
return idAsHex();
}
/**
* Returns the reference time as defined in RFC-1305.
*
* @return the reference time as TimeStamp object. Never returns null.
*/
@Override
public TimeStamp getReferenceTimeStamp() {
return getTimestamp(REFERENCE_TIMESTAMP_INDEX);
}
/**
* Return root delay as defined in RFC-1305, which is the total roundtrip delay to the primary reference source, in seconds. Values can take positive and
* negative values, depending on clock precision and skew.
*
* @return root delay as defined in RFC-1305.
*/
@Override
public int getRootDelay() {
return getInt(ROOT_DELAY_INDEX);
}
/**
* Return root delay as defined in RFC-1305 in milliseconds, which is the total roundtrip delay to the primary reference source, in seconds. Values can take
* positive and negative values, depending on clock precision and skew.
*
* @return root delay in milliseconds
*/
@Override
public double getRootDelayInMillisDouble() {
final double l = getRootDelay();
return l / 65.536;
}
/**
* Returns root dispersion as defined in RFC-1305.
*
* @return root dispersion.
*/
@Override
public int getRootDispersion() {
return getInt(ROOT_DISPERSION_INDEX);
}
/**
* Returns root dispersion (as defined in RFC-1305) in milliseconds.
*
* @return root dispersion in milliseconds
*/
@Override
public long getRootDispersionInMillis() {
final long l = getRootDispersion();
return (l * 1000) / 65536L;
}
/**
* Returns root dispersion (as defined in RFC-1305) in milliseconds as double precision value.
*
* @return root dispersion in milliseconds
*/
@Override
public double getRootDispersionInMillisDouble() {
final double l = getRootDispersion();
return l / 65.536;
}
/**
* Returns Stratum as defined in RFC-1305, which indicates the stratum level of the local clock, with values defined as follows: 0=unspecified, 1=primary
* ref clock, and all others a secondary reference (via NTP).
*
* @return Stratum level as defined in RFC-1305.
*/
@Override
public int getStratum() {
return ui(buf[STRATUM_INDEX]);
}
/**
* Get NTP Timestamp at specified starting index.
*
* @param index index into data array
* @return TimeStamp object for 64 bits starting at index
*/
private TimeStamp getTimestamp(final int index) {
return new TimeStamp(getLong(index));
}
/**
* Returns the transmit timestamp as defined in RFC-1305.
*
* @return the transmit timestamp as defined in RFC-1305. Never returns a null object.
*/
@Override
public TimeStamp getTransmitTimeStamp() {
return getTimestamp(TRANSMIT_TIMESTAMP_INDEX);
}
/**
* Return type of time packet. The values (e.g. NTP, TIME, ICMP, ...) correspond to the protocol used to obtain the timing information.
*
* @return packet type string identifier which in this case is "NTP".
*/
@Override
public String getType() {
return "NTP";
}
/**
* Returns NTP version number as defined in RFC-1305.
*
* @return NTP version number.
*/
@Override
public int getVersion() {
return (ui(buf[VERSION_INDEX]) >> VERSION_SHIFT) & 0x7;
}
/**
* Computes a hashcode for this object. The result is the exclusive OR of the values of this object stored as a byte array.
*
* @return a hash code value for this object.
* @since 3.4
*/
@Override
public int hashCode() {
return java.util.Arrays.hashCode(buf);
}
private String idAsHex() {
return Integer.toHexString(getReferenceId());
}
/**
* Returns Reference id as dotted IP address.
*
* @return refId as IP address string.
*/
private String idAsIPAddress() {
return ui(buf[REFERENCE_ID_INDEX]) + "." + ui(buf[REFERENCE_ID_INDEX + 1]) + "." + ui(buf[REFERENCE_ID_INDEX + 2]) + "."
+ ui(buf[REFERENCE_ID_INDEX + 3]);
}
private String idAsString() {
final StringBuilder id = new StringBuilder();
for (int i = 0; i <= 3; i++) {
final char c = (char) buf[REFERENCE_ID_INDEX + i];
if (c == 0) { // 0-terminated string
break;
}
id.append(c);
}
return id.toString();
}
/**
* Set the contents of this object from source datagram packet.
*
* @param srcDp source DatagramPacket to copy contents from, never null.
* @throws IllegalArgumentException if srcDp is null or byte length is less than minimum length of 48 bytes
*/
@Override
public void setDatagramPacket(final DatagramPacket srcDp) {
if (srcDp == null || srcDp.getLength() < buf.length) {
throw new IllegalArgumentException();
}
final byte[] incomingBuf = srcDp.getData();
int len = srcDp.getLength();
if (len > buf.length) {
len = buf.length;
}
System.arraycopy(incomingBuf, 0, buf, 0, len);
final DatagramPacket dp = getDatagramPacket();
dp.setAddress(srcDp.getAddress());
final int port = srcDp.getPort();
dp.setPort(port > 0 ? port : NTP_PORT);
dp.setData(buf);
}
/**
* Set integer value at index position.
*
* @param idx index position
* @param value 32-bit int value
*/
private void setInt(final int idx, int value) {
for (int i = 3; i >= 0; i--) {
buf[idx + i] = (byte) (value & 0xff);
value >>>= 8; // shift right one-byte
}
}
/**
* Set leap indicator as defined in RFC-1305.
*
* @param li leap indicator.
*/
@Override
public void setLeapIndicator(final int li) {
buf[LI_INDEX] = (byte) (buf[LI_INDEX] & 0x3F | ((li & 0x3) << LI_SHIFT));
}
/**
* Set mode as defined in RFC-1305.
*
* @param mode the mode to set
*/
@Override
public void setMode(final int mode) {
buf[MODE_INDEX] = (byte) (buf[MODE_INDEX] & 0xF8 | mode & 0x7);
}
/**
* Set originate timestamp given NTP TimeStamp object. If ts is null then zero time is used.
*
* @param ts NTP timestamp
*/
@Override
public void setOriginateTimeStamp(final TimeStamp ts) {
setTimestamp(ORIGINATE_TIMESTAMP_INDEX, ts);
}
/**
* Set poll interval as defined in RFC-1305.
*
* @param poll poll interval.
*/
@Override
public void setPoll(final int poll) {
buf[POLL_INDEX] = (byte) (poll & 0xFF);
}
/**
* Set precision as defined in RFC-1305.
*
* @param precision the precision to set
* @since 3.4
*/
@Override
public void setPrecision(final int precision) {
buf[PRECISION_INDEX] = (byte) (precision & 0xFF);
}
/**
* Set receive timestamp given NTP TimeStamp object. If ts is null then zero time is used.
*
* @param ts timestamp
*/
@Override
public void setReceiveTimeStamp(final TimeStamp ts) {
setTimestamp(RECEIVE_TIMESTAMP_INDEX, ts);
}
/**
* Set reference clock identifier field with 32-bit unsigned integer value. See RFC-1305 for description.
*
* @param refId reference clock identifier.
*/
@Override
public void setReferenceId(final int refId) {
setInt(REFERENCE_ID_INDEX, refId);
}
/**
* Set Reference time with NTP timestamp. If ts is null then zero time is used.
*
* @param ts NTP timestamp
*/
@Override
public void setReferenceTime(final TimeStamp ts) {
setTimestamp(REFERENCE_TIMESTAMP_INDEX, ts);
}
/**
* Set root delay as defined in RFC-1305.
*
* @param delay root delay
* @since 3.4
*/
@Override
public void setRootDelay(final int delay) {
setInt(ROOT_DELAY_INDEX, delay);
}
/**
* Set root dispersion as defined in RFC-1305.
*
* @param dispersion root dispersion
* @since 3.4
*/
@Override
public void setRootDispersion(final int dispersion) {
setInt(ROOT_DISPERSION_INDEX, dispersion);
}
/**
* Set stratum level as defined in RFC-1305.
*
* @param stratum stratum level.
*/
@Override
public void setStratum(final int stratum) {
buf[STRATUM_INDEX] = (byte) (stratum & 0xFF);
}
/**
* Sets the NTP timestamp at the given array index.
*
* @param index index into the byte array.
* @param t TimeStamp.
*/
private void setTimestamp(final int index, final TimeStamp t) {
long ntpTime = (t == null) ? 0 : t.ntpValue();
// copy 64-bits from Long value into 8 x 8-bit bytes of array
// one byte at a time shifting 8-bits for each position.
for (int i = 7; i >= 0; i--) {
buf[index + i] = (byte) (ntpTime & 0xFF);
ntpTime >>>= 8; // shift to next byte
}
// buf[index] |= 0x80; // only set if 1900 baseline....
}
/**
* Set transmit time with NTP timestamp. If ts is null then zero time is used.
*
* @param ts NTP timestamp
*/
@Override
public void setTransmitTime(final TimeStamp ts) {
setTimestamp(TRANSMIT_TIMESTAMP_INDEX, ts);
}
/**
* Set NTP version as defined in RFC-1305.
*
* @param version NTP version.
*/
@Override
public void setVersion(final int version) {
buf[VERSION_INDEX] = (byte) (buf[VERSION_INDEX] & 0xC7 | ((version & 0x7) << VERSION_SHIFT));
}
/**
* Returns details of NTP packet as a string.
*
* @return details of NTP packet as a string.
*/
@Override
public String toString() {
return "[" + "version:" + getVersion() + ", mode:" + getMode() + ", poll:" + getPoll() + ", precision:" + getPrecision() + ", delay:" + getRootDelay()
+ ", dispersion(ms):" + getRootDispersionInMillisDouble() + ", id:" + getReferenceIdString() + ", xmitTime:"
+ getTransmitTimeStamp().toDateString() + " ]";
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ntp/NtpV3Packet.java 0000664 0000000 0000000 00000014264 14340477222 0031466 0 ustar 00root root 0000000 0000000 /*
* 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.ntp;
import java.net.DatagramPacket;
/**
* Interface for a NtpV3Packet with get/set methods corresponding to the fields in the NTP Data Message Header described in RFC 1305.
*
*/
public interface NtpV3Packet {
/**
* Standard NTP UDP port
*/
int NTP_PORT = 123;
int LI_NO_WARNING = 0;
int LI_LAST_MINUTE_HAS_61_SECONDS = 1;
int LI_LAST_MINUTE_HAS_59_SECONDS = 2;
int LI_ALARM_CONDITION = 3;
/* mode options */
int MODE_RESERVED = 0;
int MODE_SYMMETRIC_ACTIVE = 1;
int MODE_SYMMETRIC_PASSIVE = 2;
int MODE_CLIENT = 3;
int MODE_SERVER = 4;
int MODE_BROADCAST = 5;
int MODE_CONTROL_MESSAGE = 6;
int MODE_PRIVATE = 7;
int NTP_MINPOLL = 4; // 16 seconds
int NTP_MAXPOLL = 14; // 16284 seconds
int NTP_MINCLOCK = 1;
int NTP_MAXCLOCK = 10;
int VERSION_3 = 3;
int VERSION_4 = 4;
/*
* possible getType values such that other time-related protocols can have its information represented as NTP packets
*/
String TYPE_NTP = "NTP"; // RFC-1305/2030
String TYPE_ICMP = "ICMP"; // RFC-792
String TYPE_TIME = "TIME"; // RFC-868
String TYPE_DAYTIME = "DAYTIME"; // RFC-867
/**
* @return a datagram packet with the NTP parts already filled in
*/
DatagramPacket getDatagramPacket();
/**
* @return leap indicator as defined in RFC-1305
*/
int getLeapIndicator();
/**
* @return mode as defined in RFC-1305
*/
int getMode();
/**
* @return mode as human readable string; e.g. 3=Client
*/
String getModeName();
/**
* @return the originate time as defined in RFC-1305
*/
TimeStamp getOriginateTimeStamp();
/**
* @return poll interval as defined in RFC-1305. Field range between NTP_MINPOLL and NTP_MAXPOLL.
*/
int getPoll();
/**
* @return precision as defined in RFC-1305
*/
int getPrecision();
/**
* @return the receive time as defined in RFC-1305
*/
TimeStamp getReceiveTimeStamp();
/**
* @return the reference id (32-bit code) as defined in RFC-1305
*/
int getReferenceId();
/**
* @return the reference id string
*/
String getReferenceIdString();
/**
* @return the reference time as defined in RFC-1305
*/
TimeStamp getReferenceTimeStamp();
/**
* @return root delay as defined in RFC-1305
*/
int getRootDelay();
/**
* @return root delay in milliseconds
*/
double getRootDelayInMillisDouble();
/**
* @return root dispersion as defined in RFC-1305
*/
int getRootDispersion();
/**
* @return root dispersion in milliseconds
*/
long getRootDispersionInMillis();
/**
* @return root dispersion in milliseconds
*/
double getRootDispersionInMillisDouble();
/**
* @return stratum as defined in RFC-1305
*/
int getStratum();
/**
* @return the transmit timestamp as defined in RFC-1305
*/
TimeStamp getTransmitTimeStamp();
/**
* Return type of time packet. The values (e.g. NTP, TIME, ICMP, ...) correspond to the protocol used to obtain the timing information.
*
* @return packet type string identifier
*/
String getType();
/**
* @return version as defined in RFC-1305
*/
int getVersion();
/**
* Set the contents of this object from the datagram packet
*
* @param dp the packet
*/
void setDatagramPacket(DatagramPacket dp);
/**
* Set leap indicator.
*
* @param li - leap indicator code
*/
void setLeapIndicator(int li);
/**
* Set mode as defined in RFC-1305
*
* @param mode the mode to set
*/
void setMode(int mode);
/**
* Set originate timestamp given NTP TimeStamp object.
*
* @param ts - timestamp
*/
void setOriginateTimeStamp(TimeStamp ts);
/**
* Set poll interval as defined in RFC-1305. Field range between NTP_MINPOLL and NTP_MAXPOLL.
*
* @param poll the interval to set
*/
void setPoll(int poll);
/**
* Set precision as defined in RFC-1305
*
* @param precision Precision
* @since 3.4
*/
void setPrecision(int precision);
/**
* Set receive timestamp given NTP TimeStamp object.
*
* @param ts - timestamp
*/
void setReceiveTimeStamp(TimeStamp ts);
/**
* Set reference clock identifier field.
*
* @param refId the clock id field to set
*/
void setReferenceId(int refId);
/**
* Set the reference timestamp given NTP TimeStamp object.
*
* @param ts - timestamp
*/
void setReferenceTime(TimeStamp ts);
/**
* Set root delay as defined in RFC-1305
*
* @param delay the delay to set
* @since 3.4
*/
void setRootDelay(int delay);
/**
*
* @param dispersion the value to set
* @since 3.4
*/
void setRootDispersion(int dispersion);
/**
* Set stratum as defined in RFC-1305
*
* @param stratum the stratum to set
*/
void setStratum(int stratum);
/**
* Set the transmit timestamp given NTP TimeStamp object.
*
* @param ts - timestamp
*/
void setTransmitTime(TimeStamp ts);
/**
* Set version as defined in RFC-1305
*
* @param version the version to set
*/
void setVersion(int version);
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ntp/TimeInfo.java 0000664 0000000 0000000 00000030145 14340477222 0031072 0 ustar 00root root 0000000 0000000 /*
* 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.ntp;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;
/**
* Wrapper class to network time packet messages (NTP, etc) that computes related timing info and stats.
*/
public class TimeInfo {
private final NtpV3Packet message;
private Listtrue if and only if the argument is not null and is a
* TimeStamp object that contains the same values as this object.
*
* @param obj the object to compare with.
* @return true if the objects are the same; false otherwise.
* @since 3.4
*/
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
final TimeInfo other = (TimeInfo) obj;
return returnTimeMillis == other.returnTimeMillis && message.equals(other.message);
}
/**
* Get host address from message datagram if available
*
* @return host address of available otherwise null
* @since 3.4
*/
public InetAddress getAddress() {
final DatagramPacket pkt = message.getDatagramPacket();
return pkt == null ? null : pkt.getAddress();
}
/**
* Return list of comments (if any) during processing of NTP packet.
*
* @return List or null if not yet computed
*/
public Listjava.text.SimpleDateFormat for code descriptions.
*/
public static final String NTP_DATE_FORMAT = "EEE, MMM dd yyyy HH:mm:ss.SSS";
/**
* Left-pad 8-character hex string with 0's
*
* @param buf - StringBuilder which is appended with leading 0's.
* @param l - a long.
*/
private static void appendHexString(final StringBuilder buf, final long l) {
final String s = Long.toHexString(l);
for (int i = s.length(); i < 8; i++) {
buf.append('0');
}
buf.append(s);
}
/**
* Convert NTP timestamp hexstring (e.g. "c1a089bd.fc904f6d") to the NTP 64-bit unsigned fixed-point number.
*
* @param hexString the string to convert
*
* @return NTP 64-bit timestamp value.
* @throws NumberFormatException - if the string does not contain a parsable timestamp.
*/
protected static long decodeNtpHexString(final String hexString) throws NumberFormatException {
if (hexString == null) {
throw new NumberFormatException("null");
}
final int ind = hexString.indexOf('.');
if (ind == -1) {
if (hexString.isEmpty()) {
return 0;
}
return Long.parseLong(hexString, 16) << 32; // no decimal
}
return Long.parseLong(hexString.substring(0, ind), 16) << 32 | Long.parseLong(hexString.substring(ind + 1), 16);
}
/**
* Constructs a NTP timestamp object and initializes it so that it represents the time at which it was allocated, measured to the nearest millisecond.
*
* @return NTP timestamp object set to the current time.
* @see System#currentTimeMillis()
*/
public static TimeStamp getCurrentTime() {
return getNtpTime(System.currentTimeMillis());
}
// initialization of static time bases
/*
* static { TimeZone utcZone = TimeZone.getTimeZone("UTC"); Calendar calendar = Calendar.getInstance(utcZone); calendar.set(1900, Calendar.JANUARY, 1, 0, 0,
* 0); calendar.set(Calendar.MILLISECOND, 0); msb1baseTime = calendar.getTime().getTime(); calendar.set(2036, Calendar.FEBRUARY, 7, 6, 28, 16);
* calendar.set(Calendar.MILLISECOND, 0); msb0baseTime = calendar.getTime().getTime(); }
*/
/**
* Helper method to convert Java time to NTP timestamp object. Note that Java time (milliseconds) by definition has less precision then NTP time
* (picoseconds) so converting Ntptime to Javatime and back to Ntptime loses precision. For example, Tue, Dec 17 2002 09:07:24.810 is represented by a
* single Java-based time value of f22cd1fc8a, but its NTP equivalent are all values from c1a9ae1c.cf5c28f5 to c1a9ae1c.cf9db22c.
*
* @param dateMillis the milliseconds since January 1, 1970, 00:00:00 GMT.
* @return NTP timestamp object at the specified date.
*/
public static TimeStamp getNtpTime(final long dateMillis) {
return new TimeStamp(toNtpTime(dateMillis));
}
/**
* Converts 64-bit NTP timestamp to Java standard time.
*
* Note that java time (milliseconds) by definition has less precision then NTP time (picoseconds) so converting NTP timestamp to java time and back to NTP
* timestamp loses precision. For example, Tue, Dec 17 2002 09:07:24.810 EST is represented by a single Java-based time value of f22cd1fc8a, but its NTP
* equivalent are all values ranging from c1a9ae1c.cf5c28f5 to c1a9ae1c.cf9db22c.
*
* @param ntpTimeValue the input time
* @return the number of milliseconds since January 1, 1970, 00:00:00 GMT represented by this NTP timestamp value.
*/
public static long getTime(final long ntpTimeValue) {
final long seconds = (ntpTimeValue >>> 32) & 0xffffffffL; // high-order 32-bits
long fraction = ntpTimeValue & 0xffffffffL; // low-order 32-bits
// Use round-off on fractional part to preserve going to lower precision
fraction = Math.round(1000D * fraction / 0x100000000L);
/*
* If the most significant bit (MSB) on the seconds field is set we use a different time base. The following text is a quote from RFC-2030 (SNTP v4):
*
* If bit 0 is set, the UTC time is in the range 1968-2036 and UTC time is reckoned from 0h 0m 0s UTC on 1 January 1900. If bit 0 is not set, the time
* is in the range 2036-2104 and UTC time is reckoned from 6h 28m 16s UTC on 7 February 2036.
*/
final long msb = seconds & 0x80000000L;
if (msb == 0) {
// use base: 7-Feb-2036 @ 06:28:16 UTC
return msb0baseTime + (seconds * 1000) + fraction;
}
// use base: 1-Jan-1900 @ 01:00:00 UTC
return msb1baseTime + (seconds * 1000) + fraction;
}
/**
* Parses the string argument as a NTP hexidecimal timestamp representation string (e.g. "c1a089bd.fc904f6d").
*
* @param s - hexstring.
* @return the Timestamp represented by the argument in hexidecimal.
* @throws NumberFormatException - if the string does not contain a parsable timestamp.
*/
public static TimeStamp parseNtpString(final String s) throws NumberFormatException {
return new TimeStamp(decodeNtpHexString(s));
}
/**
* Converts Java time to 64-bit NTP time representation.
*
* @param millis Java time
* @return NTP timestamp representation of Java time value.
*/
protected static long toNtpTime(final long millis) {
final boolean useBase1 = millis < msb0baseTime; // time < Feb-2036
final long baseTimeMillis;
if (useBase1) {
baseTimeMillis = millis - msb1baseTime; // dates <= Feb-2036
} else {
// if base0 needed for dates >= Feb-2036
baseTimeMillis = millis - msb0baseTime;
}
long seconds = baseTimeMillis / 1000;
final long fraction = ((baseTimeMillis % 1000) * 0x100000000L) / 1000;
if (useBase1) {
seconds |= 0x80000000L; // set high-order bit if msb1baseTime 1900 used
}
return seconds << 32 | fraction;
}
/**
* Converts 64-bit NTP timestamp value to a String. The NTP timestamp value is represented as hex string with seconds separated by fractional
* seconds by a decimal point; e.g. c1a089bd.fc904f6d == Tue, Dec 10 2002 10:41:49.986
*
* @param ntpTime the 64 bit timestamp
*
* @return NTP timestamp 64-bit long value as hex string with seconds separated by fractional seconds.
*/
public static String toString(final long ntpTime) {
final StringBuilder buf = new StringBuilder();
// high-order second bits (32..63) as hexstring
appendHexString(buf, (ntpTime >>> 32) & 0xffffffffL);
// low-order fractional seconds bits (0..31) as hexstring
buf.append('.');
appendHexString(buf, ntpTime & 0xffffffffL);
return buf.toString();
}
/**
* NTP timestamp value: 64-bit unsigned fixed-point number as defined in RFC-1305 with high-order 32 bits the seconds field and the low-order 32-bits the
* fractional field.
*/
private final long ntpTime;
private DateFormat simpleFormatter;
private DateFormat utcFormatter;
/**
* Constructs a newly allocated NTP timestamp object that represents the Java Date argument.
*
* @param d - the Date to be represented by the Timestamp object.
*/
public TimeStamp(final Date d) {
ntpTime = d == null ? 0 : toNtpTime(d.getTime());
}
/**
* Constructs a newly allocated NTP timestamp object that represents the native 64-bit long argument.
*
* @param ntpTime the timestamp
*/
public TimeStamp(final long ntpTime) {
this.ntpTime = ntpTime;
}
/**
* Constructs a newly allocated NTP timestamp object that represents the value represented by the string in hexdecimal form (e.g. "c1a089bd.fc904f6d").
*
* @param hexStamp the hex timestamp
*
* @throws NumberFormatException - if the string does not contain a parsable timestamp.
*/
public TimeStamp(final String hexStamp) throws NumberFormatException {
ntpTime = decodeNtpHexString(hexStamp);
}
/**
* Compares two Timestamps numerically.
*
* @param anotherTimeStamp - the TimeStamp to be compared.
* @return the value 0 if the argument TimeStamp is equal to this TimeStamp; a value less than 0 if this TimeStamp is numerically
* less than the TimeStamp argument; and a value greater than 0 if this TimeStamp is numerically greater than the TimeStamp argument
* (signed comparison).
*/
@Override
public int compareTo(final TimeStamp anotherTimeStamp) {
final long thisVal = this.ntpTime;
final long anotherVal = anotherTimeStamp.ntpTime;
return (Long.compare(thisVal, anotherVal));
}
/**
* Compares this object against the specified object. The result is true if and only if the argument is not null and is a
* Long object that contains the same long value as this object.
*
* @param obj the object to compare with.
* @return true if the objects are the same; false otherwise.
*/
@Override
public boolean equals(final Object obj) {
if (obj instanceof TimeStamp) {
return ntpTime == ((TimeStamp) obj).ntpValue();
}
return false;
}
/**
* Converts NTP timestamp to Java Date object.
*
* @return NTP Timestamp in Java Date
*/
public Date getDate() {
return new Date(getTime(ntpTime));
}
/**
* Returns low-order 32-bits representing the fractional seconds.
*
* @return fractional seconds represented by this NTP timestamp.
*/
public long getFraction() {
return ntpTime & 0xffffffffL;
}
/**
* Returns high-order 32-bits representing the seconds of this NTP timestamp.
*
* @return seconds represented by this NTP timestamp.
*/
public long getSeconds() {
return (ntpTime >>> 32) & 0xffffffffL;
}
/**
* Converts NTP timestamp to Java standard time.
*
* @return the number of milliseconds since January 1, 1970, 00:00:00 GMT represented by this NTP timestamp value.
*/
public long getTime() {
return getTime(ntpTime);
}
/**
* Computes a hashcode for this Timestamp. The result is the exclusive OR of the two halves of the primitive long value represented by this
* TimeStamp object. That is, the hashcode is the value of the expression:
*
*
*
* @return a hash code value for this object.
*/
@Override
public int hashCode() {
return (int) (ntpTime ^ (ntpTime >>> 32));
}
/**
* Returns the value of this Timestamp as a long value.
*
* @return the 64-bit long value represented by this object.
*/
public long ntpValue() {
return ntpTime;
}
private void readObject(final java.io.ObjectInputStream in) {
throw new UnsupportedOperationException("Serialization is not supported");
}
/**
* Converts this
* {@code
* (int) (this.ntpValue() ^ (this.ntpValue() >>> 32))
* }
*
*
* TimeStamp object to a String of the form:
*
*
See java.text.SimpleDataFormat for code descriptions.
*
* @return a string representation of this date.
*/
public String toDateString() {
if (simpleFormatter == null) {
simpleFormatter = new SimpleDateFormat(NTP_DATE_FORMAT, Locale.US);
simpleFormatter.setTimeZone(TimeZone.getDefault());
}
final Date ntpDate = getDate();
return simpleFormatter.format(ntpDate);
}
/**
* Converts this
* EEE, MMM dd yyyy HH:mm:ss.SSS
*
*
* TimeStamp object to a String. The NTP timestamp 64-bit long value is represented as hex string with seconds
* separated by fractional seconds by a decimal point; e.g. c1a089bd.fc904f6d == Tue, Dec 10 2002 10:41:49.986
*
* @return NTP timestamp 64-bit long value as hex string with seconds separated by fractional seconds.
*/
@Override
public String toString() {
return toString(ntpTime);
}
/*
* Serialization is unnecessary for this class. Reject attempts to do so until such time as the Serializable attribute can be dropped.
*/
/**
* Converts this TimeStamp object to a String of the form:
*
*
See java.text.SimpleDataFormat for code descriptions.
*
* @return a string representation of this date in UTC.
*/
public String toUTCString() {
if (utcFormatter == null) {
utcFormatter = new SimpleDateFormat(NTP_DATE_FORMAT + " 'UTC'", Locale.US);
utcFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
}
final Date ntpDate = getDate();
return utcFormatter.format(ntpDate);
}
private void writeObject(final java.io.ObjectOutputStream out) {
throw new UnsupportedOperationException("Serialization is not supported");
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/ntp/package-info.java 0000664 0000000 0000000 00000001556 14340477222 0031710 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* NTP - network time protocol
*/
package org.apache.commons.net.ntp; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/package-info.java 0000664 0000000 0000000 00000001611 14340477222 0031077 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Common socket classes and protocol command utility classes
*/
package org.apache.commons.net; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/ 0000775 0000000 0000000 00000000000 14340477222 0026572 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/ExtendedPOP3Client.java 0000664 0000000 0000000 00000013131 14340477222 0032775 0 ustar 00root root 0000000 0000000 /*
* 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.pop3;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.net.util.Base64;
/**
* A POP3 Cilent class with protocol and authentication extensions support (RFC2449 and RFC2195).
*
* @see POP3Client
* @since 3.0
*/
public class ExtendedPOP3Client extends POP3SClient {
/**
* The enumeration of currently-supported authentication methods.
*/
public enum AUTH_METHOD {
/** The standarised (RFC4616) PLAIN method, which sends the password unencrypted (insecure). */
PLAIN("PLAIN"),
/** The standarised (RFC2195) CRAM-MD5 method, which doesn't send the password (secure). */
CRAM_MD5("CRAM-MD5");
private final String methodName;
AUTH_METHOD(final String methodName) {
this.methodName = methodName;
}
/**
* Gets the name of the given authentication method suitable for the server.
*
* @return The name of the given authentication method suitable for the server.
*/
public final String getAuthName() {
return this.methodName;
}
}
/**
* The default ExtendedPOP3Client constructor. Creates a new Extended POP3 Client.
*
* @throws NoSuchAlgorithmException on error
*/
public ExtendedPOP3Client() throws NoSuchAlgorithmException {
}
/**
* Authenticate to the POP3 server by sending the AUTH command with the selected mechanism, using the given username and the given password.
*
* EEE, MMM dd yyyy HH:mm:ss.SSS UTC
*
*
* DISCONNECTED_STATE.
*/
public POP3() {
setDefaultPort(DEFAULT_PORT);
popState = DISCONNECTED_STATE;
reader = null;
writer = null;
replyLines = new ArrayList<>();
_commandSupport_ = new ProtocolCommandSupport(this);
}
/**
* Performs connection initialization and sets state to AUTHORIZATION_STATE .
*/
@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();
setState(AUTHORIZATION_STATE);
}
/**
* Disconnects the client from the server, and sets the state to DISCONNECTED_STATE . The reply text information from the last issued command
* is voided to allow garbage collection of the memory used to store that information.
*
* @throws IOException If there is an error in disconnecting.
*/
@Override
public void disconnect() throws IOException {
super.disconnect();
reader = null;
writer = null;
lastReplyLine = null;
replyLines.clear();
setState(DISCONNECTED_STATE);
}
/**
* Retrieves the additional lines of a multi-line server reply.
*
* @throws IOException on error
*/
public void getAdditionalReply() throws IOException {
String line;
line = reader.readLine();
while (line != null) {
replyLines.add(line);
if (line.equals(".")) {
break;
}
line = reader.readLine();
}
}
/**
* Provide command support to super-class
*/
@Override
protected ProtocolCommandSupport getCommandSupport() {
return _commandSupport_;
}
private void getReply() throws IOException {
final String line;
replyLines.clear();
line = reader.readLine();
if (line == null) {
throw new EOFException("Connection closed without indication.");
}
if (line.startsWith(OK)) {
replyCode = POP3Reply.OK;
} else if (line.startsWith(ERROR)) {
replyCode = POP3Reply.ERROR;
} else if (line.startsWith(OK_INT)) {
replyCode = POP3Reply.OK_INT;
} else {
throw new MalformedServerReplyException("Received invalid POP3 protocol response from server." + line);
}
replyLines.add(line);
lastReplyLine = line;
fireReplyReceived(replyCode, getReplyString());
}
/**
* Returns 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 getReplyString again. You only have to worry about this if you are implementing your own client using the
* {@link #sendCommand sendCommand } methods.
*
* @return The last server response.
*/
public String getReplyString() {
final StringBuilder buffer = new StringBuilder(256);
for (final String entry : replyLines) {
buffer.append(entry);
buffer.append(SocketClient.NETASCII_EOL);
}
return buffer.toString();
}
/**
* Returns 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 getReplyStrings again. You only have to worry about this if you are implementing your own client using the
* {@link #sendCommand sendCommand } methods.
*
* @return The last server response.
*/
public String[] getReplyStrings() {
return replyLines.toArray(NetConstants.EMPTY_STRING_ARRAY);
}
/**
* Returns the current POP3 client state.
*
* @return The current POP3 client state.
*/
public int getState() {
return popState;
}
/**
* Removes a ProtocolCommandListener.
*
* Delegates this incorrectly named method - removeProtocolCommandistener (note the missing "L")- to the correct method
* {@link SocketClient#removeProtocolCommandListener}
*
* @param listener The ProtocolCommandListener to remove
*/
public void removeProtocolCommandistener(final org.apache.commons.net.ProtocolCommandListener listener) {
removeProtocolCommandListener(listener);
}
/**
* Sends a command with no arguments to the server and returns the reply code.
*
* @param command The POP3 command to send (one of the POP3Command constants).
* @return The server reply code (either POP3Reply.OK, POP3Reply.ERROR or POP3Reply.OK_INT).
* @throws IOException on error
*/
public int sendCommand(final int command) throws IOException {
return sendCommand(POP3Command.commands[command], null);
}
/**
* Sends a command an arguments to the server and returns the reply code.
*
* @param command The POP3 command to send (one of the POP3Command constants).
* @param args The command arguments.
* @return The server reply code (either POP3Reply.OK, POP3Reply.ERROR or POP3Reply.OK_INT).
* @throws IOException on error
*/
public int sendCommand(final int command, final String args) throws IOException {
return sendCommand(POP3Command.commands[command], args);
}
/**
* Sends a command with no arguments to the server and returns the reply code.
*
* @param command The POP3 command to send.
* @return The server reply code (either POP3Reply.OK, POP3Reply.ERROR or POP3Reply.OK_INT).
* @throws IOException on error
*/
public int sendCommand(final String command) throws IOException {
return sendCommand(command, null);
}
/**
* Sends a command an arguments to the server and returns the reply code.
*
* @param command The POP3 command to send.
* @param args The command arguments.
* @return The server reply code (either POP3Reply.OK, POP3Reply.ERROR or POP3Reply.OK_INT).
* @throws IOException on error
*/
public int sendCommand(final String command, final String args) throws IOException {
if (writer == null) {
throw new IllegalStateException("Socket is not connected");
}
final StringBuilder __commandBuffer = new StringBuilder();
__commandBuffer.append(command);
if (args != null) {
__commandBuffer.append(' ');
__commandBuffer.append(args);
}
__commandBuffer.append(SocketClient.NETASCII_EOL);
final String message = __commandBuffer.toString();
writer.write(message);
writer.flush();
fireCommandSent(command, message);
getReply();
return replyCode;
}
/**
* Set the internal POP3 state.
*
* @param state the new state. This must be one of the _STATE constants.
*/
public void setState(final int state) {
popState = state;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/POP3Client.java 0000664 0000000 0000000 00000051110 14340477222 0031313 0 ustar 00root root 0000000 0000000 /*
* 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.pop3;
import java.io.IOException;
import java.io.Reader;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.ListIterator;
import java.util.StringTokenizer;
import org.apache.commons.net.io.DotTerminatedMessageReader;
/**
* The POP3Client class implements the client side of the Internet POP3 Protocol defined in RFC 1939. All commands are supported, including the APOP command
* which requires MD5 encryption. See RFC 1939 for more details on the POP3 protocol.
* number contains the number of messages in the mailbox, size contains the size of the mailbox
* in bytes, and identifier is null.
* number contains the message number, size contains the size of the message in bytes, and
* identifier is null.
* number contains the message number, size is undefined, and identifier
* contains the message's unique identifier.
*
*
*/
public final class POP3MessageInfo {
public int number;
public int size;
public String identifier;
/**
* Creates a POP3MessageInfo instance with number and size set to 0, and identifier set to null.
*/
public POP3MessageInfo() {
this(0, null, 0);
}
/**
* Creates a POP3MessageInfo instance with number set to num , size set to octets , and
* identifier set to null.
*
* @param num the number
* @param octets the size
*/
public POP3MessageInfo(final int num, final int octets) {
this(num, null, octets);
}
/**
* Creates a POP3MessageInfo instance with number set to num , size undefined, and identifier set to
* uid.
*
* @param num the number
* @param uid the UID
*/
public POP3MessageInfo(final int num, final String uid) {
this(num, uid, -1);
}
private POP3MessageInfo(final int num, final String uid, final int size) {
this.number = num;
this.size = size;
this.identifier = uid;
}
/**
* @since 3.6
*/
@Override
public String toString() {
return "Number: " + number + ". Size: " + size + ". Id: " + identifier;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/POP3Reply.java 0000664 0000000 0000000 00000002502 14340477222 0031171 0 ustar 00root root 0000000 0000000 /*
* 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.pop3;
/**
* POP3Reply stores POP3 reply code constants.
*/
public final class POP3Reply {
/** The reply code indicating success of an operation. */
public static final int OK = 0;
/** The reply code indicating failure of an operation. */
public static final int ERROR = 1;
/**
* The reply code indicating intermediate response to a command.
*
* @since 3.0
*/
public static final int OK_INT = 2;
// Cannot be instantiated.
private POP3Reply() {
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/POP3SClient.java 0000664 0000000 0000000 00000031467 14340477222 0031453 0 ustar 00root root 0000000 0000000 /*
* 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.pop3;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import org.apache.commons.net.io.CRLFLineReader;
import org.apache.commons.net.util.SSLContextUtils;
import org.apache.commons.net.util.SSLSocketUtils;
/**
* POP3 over SSL processing. Copied from FTPSClient.java and modified to suit POP3. If implicit mode is selected (NOT the default), SSL/TLS negotiation starts
* right after the connection has been established. In explicit mode (the default), SSL/TLS negotiation starts when the user calls execTLS() and the server
* accepts the command. Implicit usage: POP3SClient c = new POP3SClient(true); c.connect("127.0.0.1", 995); Explicit usage: POP3SClient c = new POP3SClient();
* c.connect("127.0.0.1", 110); if (c.execTLS()) { /rest of the commands here/ }
*
* Warning: the hostname is not verified against the certificate by default, use {@link #setHostnameVerifier(HostnameVerifier)} or
* {@link #setEndpointCheckingEnabled(boolean)} (on Java 1.7+) to enable verification.
*
* @since 3.0
*/
public class POP3SClient extends POP3Client {
// from http://www.iana.org/assignments/port-numbers
// pop3s 995/tcp pop3 protocol over TLS/SSL (was spop3)
// pop3s 995/udp pop3 protocol over TLS/SSL (was spop3)
private static final int DEFAULT_POP3S_PORT = 995;
/** Default secure socket protocol name, like TLS */
private static final String DEFAULT_PROTOCOL = "TLS";
/** The security mode. True - Implicit Mode / False - Explicit Mode. */
private final boolean isImplicit;
/** The secure socket protocol to be used, like SSL/TLS. */
private final String protocol;
/** The context object. */
private SSLContext context;
/**
* The cipher suites. SSLSockets have a default set of these anyway, so no initialization required.
*/
private String[] suites;
/** The protocol versions. */
private String[] protocols // null;
;// {"SSLv2", "SSLv3", "TLSv1", "TLSv1.1", "SSLv2Hello"};
/** The FTPS {@link TrustManager} implementation, default null. */
private TrustManager trustManager;
/** The {@link KeyManager}, default null. */
private KeyManager keyManager;
/** The {@link HostnameVerifier} to use post-TLS, default null (i.e. no verification). */
private HostnameVerifier hostnameVerifier;
/** Use Java 1.7+ HTTPS Endpoint Identification Algorithim. */
private boolean tlsEndpointChecking;
/**
* Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS Sets security mode to explicit.
*/
public POP3SClient() {
this(DEFAULT_PROTOCOL, false);
}
/**
* Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS
*
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
*/
public POP3SClient(final boolean implicit) {
this(DEFAULT_PROTOCOL, implicit);
}
/**
* Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS
*
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
* @param ctx A pre-configured SSL Context.
*/
public POP3SClient(final boolean implicit, final SSLContext ctx) {
this(DEFAULT_PROTOCOL, implicit, ctx);
}
/**
* Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} - TLS - and isImplicit = false
*
* @param context A pre-configured SSL Context.
* @see #POP3SClient(boolean, SSLContext)
*/
public POP3SClient(final SSLContext context) {
this(false, context);
}
/**
* Constructor for POP3SClient. Sets security mode to explicit.
*
* @param proto the protocol.
*/
public POP3SClient(final String proto) {
this(proto, false);
}
/**
* Constructor for POP3SClient.
*
* @param proto the protocol.
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
*/
public POP3SClient(final String proto, final boolean implicit) {
this(proto, implicit, null);
}
/**
* Constructor for POP3SClient. Sets the default port to {@link #DEFAULT_POP3S_PORT} - 995 - if using implicit mode
*
* @param proto the protocol.
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
* @param ctx the context to be used
*/
public POP3SClient(final String proto, final boolean implicit, final SSLContext ctx) {
protocol = proto;
isImplicit = implicit;
context = ctx;
if (isImplicit) {
setDefaultPort(DEFAULT_POP3S_PORT);
}
}
/**
* Because there are so many connect() methods, the _connectAction_() method is provided as a means of performing some action immediately after establishing
* a connection, rather than reimplementing all of the connect() methods.
*
* @throws IOException If it is thrown by _connectAction_().
* @see org.apache.commons.net.SocketClient#_connectAction_()
*/
@Override
protected void _connectAction_() throws IOException {
// Implicit mode.
if (isImplicit) {
applySocketAttributes();
performSSLNegotiation();
}
super._connectAction_();
// Explicit mode - don't do anything. The user calls execTLS()
}
/**
* The TLS command execution.
*
* @throws SSLException If the server reply code is not positive.
* @throws IOException If an I/O error occurs while sending the command or performing the negotiation.
* @return TRUE if the command and negotiation succeeded.
*/
public boolean execTLS() throws SSLException, IOException {
if (sendCommand("STLS") != POP3Reply.OK) {
return false;
// throw new SSLException(getReplyString());
}
performSSLNegotiation();
return true;
}
/**
* Returns the names of the cipher suites which could be enabled for use on this connection. When the underlying {@link java.net.Socket Socket} is not an
* {@link SSLSocket} instance, returns null.
*
* @return An array of cipher suite names, or null.
*/
public String[] getEnabledCipherSuites() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledCipherSuites();
}
return null;
}
/**
* Returns the names of the protocol versions which are currently enabled for use on this connection. When the underlying {@link java.net.Socket Socket} is
* not an {@link SSLSocket} instance, returns null.
*
* @return An array of protocols, or null.
*/
public String[] getEnabledProtocols() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledProtocols();
}
return null;
}
/**
* Get the currently configured {@link HostnameVerifier}.
*
* @return A HostnameVerifier instance.
* @since 3.4
*/
public HostnameVerifier getHostnameVerifier() {
return hostnameVerifier;
}
/**
* Get the {@link KeyManager} instance.
*
* @return The current {@link KeyManager} instance.
*/
private KeyManager getKeyManager() {
return keyManager;
}
/**
* Get the currently configured {@link TrustManager}.
*
* @return A TrustManager instance.
*/
public TrustManager getTrustManager() {
return trustManager;
}
/**
* Performs a lazy init of the SSL context.
*
* @throws IOException When could not initialize the SSL context.
*/
private void initSSLContext() throws IOException {
if (context == null) {
context = SSLContextUtils.createSSLContext(protocol, getKeyManager(), getTrustManager());
}
}
/**
* Return whether or not endpoint identification using the HTTPS algorithm on Java 1.7+ is enabled. The default behavior is for this to be disabled.
*
* @return True if enabled, false if not.
* @since 3.4
*/
public boolean isEndpointCheckingEnabled() {
return tlsEndpointChecking;
}
/**
* SSL/TLS negotiation. Acquires an SSL socket of a connection and carries out handshake processing.
*
* @throws IOException If server negotiation fails.
*/
private void performSSLNegotiation() throws IOException {
initSSLContext();
final SSLSocketFactory ssf = context.getSocketFactory();
final String host = _hostname_ != null ? _hostname_ : getRemoteAddress().getHostAddress();
final int port = getRemotePort();
final SSLSocket socket = (SSLSocket) ssf.createSocket(_socket_, host, port, true);
socket.setEnableSessionCreation(true);
socket.setUseClientMode(true);
if (tlsEndpointChecking) {
SSLSocketUtils.enableEndpointNameVerification(socket);
}
if (protocols != null) {
socket.setEnabledProtocols(protocols);
}
if (suites != null) {
socket.setEnabledCipherSuites(suites);
}
socket.startHandshake();
// TODO the following setup appears to duplicate that in the super class methods
_socket_ = socket;
_input_ = socket.getInputStream();
_output_ = socket.getOutputStream();
reader = new CRLFLineReader(new InputStreamReader(_input_, DEFAULT_ENCODING));
writer = new BufferedWriter(new OutputStreamWriter(_output_, DEFAULT_ENCODING));
if (hostnameVerifier != null && !hostnameVerifier.verify(host, socket.getSession())) {
throw new SSLHandshakeException("Hostname doesn't match certificate");
}
}
/**
* Controls which particular cipher suites are enabled for use on this connection. Called before server negotiation.
*
* @param cipherSuites The cipher suites.
*/
public void setEnabledCipherSuites(final String[] cipherSuites) {
suites = cipherSuites.clone();
}
/**
* Controls which particular protocol versions are enabled for use on this connection. I perform setting before a server negotiation.
*
* @param protocolVersions The protocol versions.
*/
public void setEnabledProtocols(final String[] protocolVersions) {
protocols = protocolVersions.clone();
}
/**
* Automatic endpoint identification checking using the HTTPS algorithm is supported on Java 1.7+. The default behavior is for this to be disabled.
*
* @param enable Enable automatic endpoint identification checking using the HTTPS algorithm on Java 1.7+.
* @since 3.4
*/
public void setEndpointCheckingEnabled(final boolean enable) {
tlsEndpointChecking = enable;
}
/**
* Override the default {@link HostnameVerifier} to use.
*
* @param newHostnameVerifier The HostnameVerifier implementation to set or null to disable.
* @since 3.4
*/
public void setHostnameVerifier(final HostnameVerifier newHostnameVerifier) {
hostnameVerifier = newHostnameVerifier;
}
/**
* Set a {@link KeyManager} to use.
*
* @param newKeyManager The KeyManager implementation to set.
* @see org.apache.commons.net.util.KeyManagerUtils
*/
public void setKeyManager(final KeyManager newKeyManager) {
keyManager = newKeyManager;
}
/**
* Override the default {@link TrustManager} to use.
*
* @param newTrustManager The TrustManager implementation to set.
* @see org.apache.commons.net.util.TrustManagerUtils
*/
public void setTrustManager(final TrustManager newTrustManager) {
trustManager = newTrustManager;
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/pop3/package-info.java 0000664 0000000 0000000 00000001547 14340477222 0031770 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* POP3 and POP3S mail
*/
package org.apache.commons.net.pop3; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/ 0000775 0000000 0000000 00000000000 14340477222 0026674 5 ustar 00root root 0000000 0000000 AuthenticatingSMTPClient.java 0000664 0000000 0000000 00000032140 14340477222 0034272 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp /*
* 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.smtp;
import java.io.IOException;
import java.net.InetAddress;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Arrays;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.net.ssl.SSLContext;
import org.apache.commons.net.util.Base64;
/**
* An SMTP Client class with authentication support (RFC4954).
*
* @see SMTPClient
* @since 3.0
*/
public class AuthenticatingSMTPClient extends SMTPSClient {
/**
* The enumeration of currently-supported authentication methods.
*/
public enum AUTH_METHOD {
/** The standarised (RFC4616) PLAIN method, which sends the password unencrypted (insecure). */
PLAIN,
/** The standarised (RFC2195) CRAM-MD5 method, which doesn't send the password (secure). */
CRAM_MD5,
/** The unstandarised Microsoft LOGIN method, which sends the password unencrypted (insecure). */
LOGIN,
/** XOAuth method which accepts a signed and base64ed OAuth URL. */
XOAUTH,
/** XOAuth 2 method which accepts a signed and base64ed OAuth JSON. */
XOAUTH2;
/**
* Gets the name of the given authentication method suitable for the server.
*
* @param method The authentication method to get the name for.
* @return The name of the given authentication method suitable for the server.
*/
public static final String getAuthName(final AUTH_METHOD method) {
if (method.equals(AUTH_METHOD.PLAIN)) {
return "PLAIN";
}
if (method.equals(AUTH_METHOD.CRAM_MD5)) {
return "CRAM-MD5";
}
if (method.equals(AUTH_METHOD.LOGIN)) {
return "LOGIN";
}
if (method.equals(AUTH_METHOD.XOAUTH)) {
return "XOAUTH";
}
if (method.equals(AUTH_METHOD.XOAUTH2)) {
return "XOAUTH2";
}
return null;
}
}
/**
* The default AuthenticatingSMTPClient constructor. Creates a new Authenticating SMTP Client.
*/
public AuthenticatingSMTPClient() {
}
/**
* Overloaded constructor that takes the implicit argument, and using {@link #DEFAULT_PROTOCOL} i.e. TLS
*
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
* @param ctx A pre-configured SSL Context.
* @since 3.3
*/
public AuthenticatingSMTPClient(final boolean implicit, final SSLContext ctx) {
super(implicit, ctx);
}
/**
* Overloaded constructor that takes a protocol specification
*
* @param protocol The protocol to use
*/
public AuthenticatingSMTPClient(final String protocol) {
super(protocol);
}
/**
* Overloaded constructor that takes a protocol specification and the implicit argument
*
* @param proto the protocol.
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
* @since 3.3
*/
public AuthenticatingSMTPClient(final String proto, final boolean implicit) {
super(proto, implicit);
}
/**
* Overloaded constructor that takes the protocol specification, the implicit argument and encoding
*
* @param proto the protocol.
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
* @param encoding the encoding
* @since 3.3
*/
public AuthenticatingSMTPClient(final String proto, final boolean implicit, final String encoding) {
super(proto, implicit, encoding);
}
/**
* Overloaded constructor that takes a protocol specification and encoding
*
* @param protocol The protocol to use
* @param encoding The encoding to use
* @since 3.3
*/
public AuthenticatingSMTPClient(final String protocol, final String encoding) {
super(protocol, false, encoding);
}
/**
* Authenticate to the SMTP server by sending the AUTH command with the selected mechanism, using the given username and the given password.
*
* @param method the method to use, one of the {@link AuthenticatingSMTPClient.AUTH_METHOD} enum values
* @param username the user name. If the method is XOAUTH/XOAUTH2, then this is used as the plain text oauth protocol parameter string which is
* Base64-encoded for transmission.
* @param password the password for the username. Ignored for XOAUTH/XOAUTH2.
*
* @return True if successfully completed, false if not.
* @throws SMTPConnectionClosedException If the SMTP server prematurely closes the connection as a result of the client being idle or some other reason
* causing the server to send SMTP reply code 421. This exception may be caught either as an IOException or
* independently as itself.
* @throws IOException If an I/O error occurs while either sending a command to the server or receiving a reply from the server.
* @throws NoSuchAlgorithmException If the CRAM hash algorithm cannot be instantiated by the Java runtime system.
* @throws InvalidKeyException If the CRAM hash algorithm failed to use the given password.
* @throws InvalidKeySpecException If the CRAM hash algorithm failed to use the given password.
*/
public boolean auth(final AuthenticatingSMTPClient.AUTH_METHOD method, final String username, final String password)
throws IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidKeySpecException {
if (!SMTPReply.isPositiveIntermediate(sendCommand(SMTPCommand.AUTH, AUTH_METHOD.getAuthName(method)))) {
return false;
}
if (method.equals(AUTH_METHOD.PLAIN)) {
// the server sends an empty response ("334 "), so we don't have to read it.
return SMTPReply
.isPositiveCompletion(sendCommand(Base64.encodeBase64StringUnChunked(("\000" + username + "\000" + password).getBytes(getCharset()))));
}
if (method.equals(AUTH_METHOD.CRAM_MD5)) {
// get the CRAM challenge
final byte[] serverChallenge = Base64.decodeBase64(getReplyString().substring(4).trim());
// get the Mac instance
final Mac hmac_md5 = Mac.getInstance("HmacMD5");
hmac_md5.init(new SecretKeySpec(password.getBytes(getCharset()), "HmacMD5"));
// compute the result:
final byte[] hmacResult = convertToHexString(hmac_md5.doFinal(serverChallenge)).getBytes(getCharset());
// join the byte arrays to form the reply
final byte[] usernameBytes = username.getBytes(getCharset());
final byte[] toEncode = new byte[usernameBytes.length + 1 /* the space */ + hmacResult.length];
System.arraycopy(usernameBytes, 0, toEncode, 0, usernameBytes.length);
toEncode[usernameBytes.length] = ' ';
System.arraycopy(hmacResult, 0, toEncode, usernameBytes.length + 1, hmacResult.length);
// send the reply and read the server code:
return SMTPReply.isPositiveCompletion(sendCommand(Base64.encodeBase64StringUnChunked(toEncode)));
}
if (method.equals(AUTH_METHOD.LOGIN)) {
// the server sends fixed responses (base64("Username") and
// base64("Password")), so we don't have to read them.
if (!SMTPReply.isPositiveIntermediate(sendCommand(Base64.encodeBase64StringUnChunked(username.getBytes(getCharset()))))) {
return false;
}
return SMTPReply.isPositiveCompletion(sendCommand(Base64.encodeBase64StringUnChunked(password.getBytes(getCharset()))));
}
if (method.equals(AUTH_METHOD.XOAUTH) || method.equals(AUTH_METHOD.XOAUTH2)) {
return SMTPReply.isPositiveIntermediate(sendCommand(Base64.encodeBase64StringUnChunked(username.getBytes(getCharset()))));
}
return false; // safety check
}
/**
* Converts the given byte array to a String containing the hex values of the bytes. For example, the byte 'A' will be converted to '41', because this is
* the ASCII code (and the byte value) of the capital letter 'A'.
*
* @param a The byte array to convert.
* @return The resulting String of hex codes.
*/
private String convertToHexString(final byte[] a) {
final StringBuilder result = new StringBuilder(a.length * 2);
for (final byte element : a) {
if ((element & 0x0FF) <= 15) {
result.append("0");
}
result.append(Integer.toHexString(element & 0x0FF));
}
return result.toString();
}
/**
* A convenience method to send the ESMTP EHLO command to the server, receive the reply, and return the reply code.
* < @bar.com,@foo.com:foobar@foo.com >
*
*
* path = new RelayPath("foobar@foo.com");
* path.addRelay("bar.com");
* path.addRelay("foo.com");
*
* SMTPConectionClosedException is a subclass of 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 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
* getReplyStrings}.
* DEFAULT_PORT and initializes internal data structures for saving SMTP reply
* information.
*/
public SMTP() {
this(DEFAULT_ENCODING);
}
/**
* Overloaded constructor where the user may specify a default encoding.
*
* @param encoding the encoing to use
* @since 2.0
*/
public SMTP(final String encoding) {
setDefaultPort(DEFAULT_PORT);
replyLines = new ArrayList<>();
newReplyString = false;
replyString = null;
_commandSupport_ = new ProtocolCommandSupport(this);
this.encoding = encoding;
}
/** Initiates control connections and gets initial reply. */
@Override
protected void _connectAction_() throws IOException {
super._connectAction_();
reader = new CRLFLineReader(new InputStreamReader(_input_, encoding));
writer = new BufferedWriter(new OutputStreamWriter(_output_, encoding));
getReply();
}
/**
* A convenience method to send the SMTP DATA command to the server, receive the reply, and return the reply code.
* connect is of type void.
*
* try {
* int reply;
* client.connect("mail.foobar.com");
* System.out.print(client.getReplyString());
*
* // After connection attempt, you should check the reply code to verify
* // success.
* reply = client.getReplyCode();
*
* if(!SMTPReply.isPositiveCompletion(reply)) {
* client.disconnect();
* System.err.println("SMTP server refused connection.");
* System.exit(1);
* }
*
* // Do useful stuff here.
* ...
* } catch(IOException e) {
* if(client.isConnected()) {
* try {
* client.disconnect();
* } catch(IOException f) {
* // do nothing
* }
* }
* System.err.println("Could not connect to server.");
* e.printStackTrace();
* System.exit(1);
* }
*
* SMTPConectionClosedException is a subclass of 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 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#getReplyStrings getReplyStrings}.
*
* writer = client.sendMessageData();
* if (writer == null) // failure
* return false;
* header = new SimpleSMTPHeader("foobar@foo.com", "foo@foobar.com", "Re: Foo");
* writer.write(header.toString());
* writer.write("This is just a test");
* writer.close();
* if (!client.completePendingCommand()) // failure
* return false;
*
*
* SMTPSClient c = new SMTPSClient(true);
* c.connect("127.0.0.1", 465);
*
*
* Explicit usage:
*
*
* SMTPSClient c = new SMTPSClient();
* c.connect("127.0.0.1", 25);
* if (c.execTLS()) {
* // Rest of the commands here
* }
*
*
* Warning: the hostname is not verified against the certificate by default, use {@link #setHostnameVerifier(HostnameVerifier)} or
* {@link #setEndpointCheckingEnabled(boolean)} (on Java 1.7+) to enable verification.
*
* @since 3.0
*/
public class SMTPSClient extends SMTPClient {
/** Default secure socket protocol name, like TLS */
private static final String DEFAULT_PROTOCOL = "TLS";
/** The security mode. True - Implicit Mode / False - Explicit Mode. */
private final boolean isImplicit;
/** The secure socket protocol to be used, like SSL/TLS. */
private final String protocol;
/** The context object. */
private SSLContext context;
/**
* The cipher suites. SSLSockets have a default set of these anyway, so no initialization required.
*/
private String[] suites;
/** The protocol versions. */
private String[] protocols;
/** The {@link TrustManager} implementation, default null (i.e. use system managers). */
private TrustManager trustManager;
/** The {@link KeyManager}, default null (i.e. use system managers). */
private KeyManager keyManager; // seems not to be required
/** The {@link HostnameVerifier} to use post-TLS, default null (i.e. no verification). */
private HostnameVerifier hostnameVerifier;
/** Use Java 1.7+ HTTPS Endpoint Identification Algorithim. */
private boolean tlsEndpointChecking;
/**
* Constructor for SMTPSClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS Sets security mode to explicit (isImplicit = false).
*/
public SMTPSClient() {
this(DEFAULT_PROTOCOL, false);
}
/**
* Constructor for SMTPSClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS
*
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
*/
public SMTPSClient(final boolean implicit) {
this(DEFAULT_PROTOCOL, implicit);
}
/**
* Constructor for SMTPSClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS
*
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
* @param ctx A pre-configured SSL Context.
*/
public SMTPSClient(final boolean implicit, final SSLContext ctx) {
isImplicit = implicit;
context = ctx;
protocol = DEFAULT_PROTOCOL;
}
/**
* Constructor for SMTPSClient.
*
* @param context A pre-configured SSL Context.
* @see #SMTPSClient(boolean, SSLContext)
*/
public SMTPSClient(final SSLContext context) {
this(false, context);
}
/**
* Constructor for SMTPSClient, using explicit security mode.
*
* @param proto the protocol.
*/
public SMTPSClient(final String proto) {
this(proto, false);
}
/**
* Constructor for SMTPSClient.
*
* @param proto the protocol.
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
*/
public SMTPSClient(final String proto, final boolean implicit) {
protocol = proto;
isImplicit = implicit;
}
/**
* Constructor for SMTPSClient.
*
* @param proto the protocol.
* @param implicit The security mode, {@code true} for implicit, {@code false} for explicit
* @param encoding the encoding
* @since 3.3
*/
public SMTPSClient(final String proto, final boolean implicit, final String encoding) {
super(encoding);
protocol = proto;
isImplicit = implicit;
}
/**
* Because there are so many connect() methods, the _connectAction_() method is provided as a means of performing some action immediately after establishing
* a connection, rather than reimplementing all of the connect() methods.
*
* @throws IOException If it is thrown by _connectAction_().
* @see org.apache.commons.net.SocketClient#_connectAction_()
*/
@Override
protected void _connectAction_() throws IOException {
// Implicit mode.
if (isImplicit) {
applySocketAttributes();
performSSLNegotiation();
}
super._connectAction_();
// Explicit mode - don't do anything. The user calls execTLS()
}
/**
* The TLS command execution.
*
* @throws IOException If an I/O error occurs while sending the command or performing the negotiation.
* @return TRUE if the command and negotiation succeeded.
*/
public boolean execTLS() throws IOException {
if (!SMTPReply.isPositiveCompletion(sendCommand("STARTTLS"))) {
return false;
// throw new SSLException(getReplyString());
}
performSSLNegotiation();
return true;
}
/**
* Returns the names of the cipher suites which could be enabled for use on this connection. When the underlying {@link java.net.Socket Socket} is not an
* {@link SSLSocket} instance, returns null.
*
* @return An array of cipher suite names, or null.
*/
public String[] getEnabledCipherSuites() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledCipherSuites();
}
return null;
}
/**
* Returns the names of the protocol versions which are currently enabled for use on this connection. When the underlying {@link java.net.Socket Socket} is
* not an {@link SSLSocket} instance, returns null.
*
* @return An array of protocols, or null.
*/
public String[] getEnabledProtocols() {
if (_socket_ instanceof SSLSocket) {
return ((SSLSocket) _socket_).getEnabledProtocols();
}
return null;
}
/**
* Get the currently configured {@link HostnameVerifier}.
*
* @return A HostnameVerifier instance.
* @since 3.4
*/
public HostnameVerifier getHostnameVerifier() {
return hostnameVerifier;
}
/**
* Get the {@link KeyManager} instance.
*
* @return The current {@link KeyManager} instance.
*/
public KeyManager getKeyManager() {
return keyManager;
}
/**
* Get the currently configured {@link TrustManager}.
*
* @return A TrustManager instance.
*/
public TrustManager getTrustManager() {
return trustManager;
}
/**
* Performs a lazy init of the SSL context.
*
* @throws IOException When could not initialize the SSL context.
*/
private void initSSLContext() throws IOException {
if (context == null) {
context = SSLContextUtils.createSSLContext(protocol, getKeyManager(), getTrustManager());
}
}
/**
* Return whether or not endpoint identification using the HTTPS algorithm on Java 1.7+ is enabled. The default behavior is for this to be disabled.
*
* @return True if enabled, false if not.
* @since 3.4
*/
public boolean isEndpointCheckingEnabled() {
return tlsEndpointChecking;
}
/**
* SSL/TLS negotiation. Acquires an SSL socket of a connection and carries out handshake processing.
*
* @throws IOException If server negotiation fails.
*/
private void performSSLNegotiation() throws IOException {
initSSLContext();
final SSLSocketFactory ssf = context.getSocketFactory();
final String host = _hostname_ != null ? _hostname_ : getRemoteAddress().getHostAddress();
final int port = getRemotePort();
final SSLSocket socket = (SSLSocket) ssf.createSocket(_socket_, host, port, true);
socket.setEnableSessionCreation(true);
socket.setUseClientMode(true);
if (tlsEndpointChecking) {
SSLSocketUtils.enableEndpointNameVerification(socket);
}
if (protocols != null) {
socket.setEnabledProtocols(protocols);
}
if (suites != null) {
socket.setEnabledCipherSuites(suites);
}
socket.startHandshake();
// TODO the following setup appears to duplicate that in the super class methods
_socket_ = socket;
_input_ = socket.getInputStream();
_output_ = socket.getOutputStream();
reader = new CRLFLineReader(new InputStreamReader(_input_, encoding));
writer = new BufferedWriter(new OutputStreamWriter(_output_, encoding));
if (hostnameVerifier != null && !hostnameVerifier.verify(host, socket.getSession())) {
throw new SSLHandshakeException("Hostname doesn't match certificate");
}
}
/**
* Controls which particular cipher suites are enabled for use on this connection. Called before server negotiation.
*
* @param cipherSuites The cipher suites.
*/
public void setEnabledCipherSuites(final String[] cipherSuites) {
suites = cipherSuites.clone();
}
/**
* Controls which particular protocol versions are enabled for use on this connection. I perform setting before a server negotiation.
*
* @param protocolVersions The protocol versions.
*/
public void setEnabledProtocols(final String[] protocolVersions) {
protocols = protocolVersions.clone();
}
/**
* Automatic endpoint identification checking using the HTTPS algorithm is supported on Java 1.7+. The default behavior is for this to be disabled.
*
* @param enable Enable automatic endpoint identification checking using the HTTPS algorithm on Java 1.7+.
* @since 3.4
*/
public void setEndpointCheckingEnabled(final boolean enable) {
tlsEndpointChecking = enable;
}
/**
* Override the default {@link HostnameVerifier} to use.
*
* @param newHostnameVerifier The HostnameVerifier implementation to set or null to disable.
* @since 3.4
*/
public void setHostnameVerifier(final HostnameVerifier newHostnameVerifier) {
hostnameVerifier = newHostnameVerifier;
}
/**
* Set a {@link KeyManager} to use.
*
* @param newKeyManager The KeyManager implementation to set.
* @see org.apache.commons.net.util.KeyManagerUtils
*/
public void setKeyManager(final KeyManager newKeyManager) {
keyManager = newKeyManager;
}
/**
* Override the default {@link TrustManager} to use.
*
* @param newTrustManager The TrustManager implementation to set.
* @see org.apache.commons.net.util.TrustManagerUtils
*/
public void setTrustManager(final TrustManager newTrustManager) {
trustManager = newTrustManager;
}
}
/* kate: indent-width 4; replace-tabs on; */
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/smtp/SimpleSMTPHeader.java 0000664 0000000 0000000 00000012654 14340477222 0032615 0 ustar 00root root 0000000 0000000 /*
* 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.smtp;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
* This class is used to construct a bare minimum acceptable header for an email message. To construct more complicated headers you should refer to RFC 5322.
* When the Java Mail API is finalized, you will be able to use it to compose fully compliant Internet text messages.
*
* writer = client.sendMessageData();
* if(writer == null) // failure
* return false;
* header =
* new SimpleSMTPHeader("foobar@foo.com", "foo@bar.com" "Just testing");
* header.addCC("bar@foo.com");
* header.addHeaderField("Organization", "Foobar, Inc.");
* writer.write(header.toString());
* writer.write("This is just a test");
* writer.close();
* if(!client.completePendingCommand()) // failure
* return false;
*
*
* @see SMTPClient
*/
public class SimpleSMTPHeader {
private final String subject;
private final String from;
private final String to;
private final StringBuffer headerFields;
private boolean hasHeaderDate;
private StringBuffer cc;
/**
* Creates a new SimpleSMTPHeader instance initialized with the given from, to, and subject header field values.
* From: header field. This should be the sender's email address. Must not be null.
* @param to The value of the To: header field. This should be the recipient's email address. May be null
* @param subject The value of the Subject: header field. This should be the subject of the message. May be null
*/
public SimpleSMTPHeader(final String from, final String to, final String subject) {
if (from == null) {
throw new IllegalArgumentException("From cannot be null");
}
this.to = to;
this.from = from;
this.subject = subject;
this.headerFields = new StringBuffer();
this.cc = null;
}
/**
* Add an email address to the CC (carbon copy or courtesy copy) list.
*
* header.addHeaderField("Organization", "Foobar, Inc.");
*
*
* {@code System.out.println(direction + " " + packet.toString());}
*
* @param direction {@code >} or {@code <}
* @param packet the packet to be sent or that has been received respectively
* @since 3.6
*/
protected void trace(final String direction, final TFTPPacket packet) {
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/tftp/TFTPAckPacket.java 0000664 0000000 0000000 00000012533 14340477222 0032061 0 ustar 00root root 0000000 0000000 /*
* 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.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/**
* A final class derived from TFTPPacket definiing the TFTP Acknowledgement packet type.
* DEFAULT_PORT .
*/
public TimeTCPClient() {
setDefaultPort(DEFAULT_PORT);
}
/**
* Retrieves the time from the server and returns a Java Date containing the time converted to the local time zone.
* getDate() again.
*
* @return A Date value containing the time retrieved from the server converted to the local time zone.
* @throws IOException If an error occurs while fetching the time.
*/
public Date getDate() throws IOException {
return new Date((getTime() - SECONDS_1900_TO_1970) * 1000L);
}
/**
* Retrieves 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.
* getTime() again.
*
* @return The time value retrieved from the server.
* @throws IOException If an error occurs while fetching the time.
*/
public long getTime() throws IOException {
final DataInputStream input;
input = new DataInputStream(_input_);
return input.readInt() & 0xffffffffL;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/time/TimeUDPClient.java 0000664 0000000 0000000 00000011260 14340477222 0032120 0 ustar 00root root 0000000 0000000 /*
* 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.time;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.util.Date;
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
* re-establishing a connection. That is because UDP is a connectionless protocol and the Time protocol is stateless.
*
*
* @see TimeTCPClient
*/
public final class TimeUDPClient extends DatagramSocketClient {
/** The default time port. It is set to 37 according to RFC 868. */
public static final int DEFAULT_PORT = 37;
/**
* The number of seconds between 00:00 1 January 1900 and 00:00 1 January 1970. This value can be useful for converting time values to other formats.
*/
public static final long SECONDS_1900_TO_1970 = 2208988800L;
private final byte[] dummyData = new byte[1];
private final byte[] timeData = new byte[4];
/**
* Same as getTime(host, DEFAULT_PORT);
*
* @param host the time server
* @return the date
* @throws IOException on error
*/
public Date getDate(final InetAddress host) throws IOException {
return new Date((getTime(host, DEFAULT_PORT) - SECONDS_1900_TO_1970) * 1000L);
}
/**
* Retrieves the time from the server and returns a Java Date containing the time converted to the local time zone.
*
* @param host The address of the server.
* @param port The port of the service.
* @return A Date value containing the time retrieved from the server converted to the local time zone.
* @throws IOException If an error occurs while fetching the time.
*/
public Date getDate(final InetAddress host, final int port) throws IOException {
return new Date((getTime(host, port) - SECONDS_1900_TO_1970) * 1000L);
}
/**
* Same as getTime(host, DEFAULT_PORT);
*
* @param host the time server
* @return the time returned from the server
* @throws IOException on error
*/
public long getTime(final InetAddress host) throws IOException {
return getTime(host, DEFAULT_PORT);
}
/**
* Retrieves the time from the specified server and port 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.
*
* @param host The address of the server.
* @param port The port of the service.
* @return The time value retrieved from the server.
* @throws IOException If an error occurs while retrieving the time.
*/
public long getTime(final InetAddress host, final int port) throws IOException {
long time;
final DatagramPacket sendPacket;
final DatagramPacket receivePacket;
sendPacket = new DatagramPacket(dummyData, dummyData.length, host, port);
receivePacket = new DatagramPacket(timeData, timeData.length);
_socket_.send(sendPacket);
_socket_.receive(receivePacket);
time = 0L;
time |= (((timeData[0] & 0xff) << 24) & 0xffffffffL);
time |= (((timeData[1] & 0xff) << 16) & 0xffffffffL);
time |= (((timeData[2] & 0xff) << 8) & 0xffffffffL);
time |= ((timeData[3] & 0xff) & 0xffffffffL);
return time;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/time/package-info.java 0000664 0000000 0000000 00000001574 14340477222 0032045 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Time protocol (RFC 868) over TCP and UDP
*/
package org.apache.commons.net.time; commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/util/ 0000775 0000000 0000000 00000000000 14340477222 0026666 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/util/Base64.java 0000664 0000000 0000000 00000112156 14340477222 0030563 0 ustar 00root root 0000000 0000000 /*
* 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.util;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
/**
* Provides Base64 encoding and decoding as defined by RFC 2045.
*
*
*
* true if any byte is a valid character in the Base64 alphabet; false herwise
*/
private static boolean containsBase64Byte(final byte[] arrayOctet) {
for (final byte element : arrayOctet) {
if (isBase64(element)) {
return true;
}
}
return false;
}
/**
* Decodes Base64 data into octets.
*
* @param base64Data Byte array containing Base64 data
* @return Array containing decoded data.
*/
public static byte[] decodeBase64(final byte[] base64Data) {
return new Base64().decode(base64Data);
}
/**
* Decodes a Base64 String into octets.
*
* @param base64String String containing Base64 data
* @return Array containing decoded data.
* @since 1.4
*/
public static byte[] decodeBase64(final String base64String) {
return new Base64().decode(base64String);
}
// Implementation of integer encoding used for crypto
/**
* Decodes a byte64-encoded integer according to crypto standards such as W3C's XML-Signature
*
* @param pArray a byte array containing base64 character data
* @return A BigInteger
* @since 1.4
*/
public static BigInteger decodeInteger(final byte[] pArray) {
return new BigInteger(1, decodeBase64(pArray));
}
/**
* Encodes binary data using the base64 algorithm but does not chunk the output.
*
* @param binaryData binary data to encode
* @return byte[] containing Base64 characters in their UTF-8 representation.
*/
public static byte[] encodeBase64(final byte[] binaryData) {
return encodeBase64(binaryData, false);
}
/**
* Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
*
* @param binaryData Array containing binary data to encode.
* @param isChunked if true this encoder will chunk the base64 output into 76 character blocks
* @return Base64-encoded data.
* @throws IllegalArgumentException Thrown when the input array needs an output array bigger than {@link Integer#MAX_VALUE}
*/
public static byte[] encodeBase64(final byte[] binaryData, final boolean isChunked) {
return encodeBase64(binaryData, isChunked, false);
}
/**
* Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
*
* @param binaryData Array containing binary data to encode.
* @param isChunked if true this encoder will chunk the base64 output into 76 character blocks
* @param urlSafe if true this encoder will emit - and _ instead of the usual + and / characters.
* @return Base64-encoded data.
* @throws IllegalArgumentException Thrown when the input array needs an output array bigger than {@link Integer#MAX_VALUE}
* @since 1.4
*/
public static byte[] encodeBase64(final byte[] binaryData, final boolean isChunked, final boolean urlSafe) {
return encodeBase64(binaryData, isChunked, urlSafe, Integer.MAX_VALUE);
}
/**
* Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
*
* @param binaryData Array containing binary data to encode.
* @param isChunked if true this encoder will chunk the base64 output into 76 character blocks
* @param urlSafe if true this encoder will emit - and _ instead of the usual + and / characters.
* @param maxResultSize The maximum result size to accept.
* @return Base64-encoded data.
* @throws IllegalArgumentException Thrown when the input array needs an output array bigger than maxResultSize
* @since 1.4
*/
public static byte[] encodeBase64(final byte[] binaryData, final boolean isChunked, final boolean urlSafe, final int maxResultSize) {
if (binaryData == null || binaryData.length == 0) {
return binaryData;
}
final long len = getEncodeLength(binaryData, isChunked ? CHUNK_SIZE : 0, isChunked ? CHUNK_SEPARATOR : NetConstants.EMPTY_BTYE_ARRAY);
if (len > maxResultSize) {
throw new IllegalArgumentException(
"Input array too big, the output array would be bigger (" + len + ") than the specified maxium size of " + maxResultSize);
}
final Base64 b64 = isChunked ? new Base64(urlSafe) : new Base64(0, CHUNK_SEPARATOR, urlSafe);
return b64.encode(binaryData);
}
/**
* Encodes binary data using the base64 algorithm and chunks the encoded output into 76 character blocks
*
* @param binaryData binary data to encode
* @return Base64 characters chunked in 76 character blocks
*/
public static byte[] encodeBase64Chunked(final byte[] binaryData) {
return encodeBase64(binaryData, true);
}
/**
* Encodes binary data using the base64 algorithm into 76 character blocks separated by CRLF.
* true if all bytes are valid characters in the Base64 alphabet or if the byte array is empty; false, otherwise
*/
public static boolean isArrayByteBase64(final byte[] arrayOctet) {
for (final byte element : arrayOctet) {
if (!isBase64(element) && !isWhiteSpace(element)) {
return false;
}
}
return true;
}
/**
* Returns whether or not the octet is in the base 64 alphabet.
*
* @param octet The value to test
* @return true if the value is defined in the the base 64 alphabet, false otherwise.
* @since 1.4
*/
public static boolean isBase64(final byte octet) {
return octet == PAD || (octet >= 0 && octet < DECODE_TABLE.length && DECODE_TABLE[octet] != -1);
}
/**
* Checks if a byte value is whitespace or not.
*
* @param byteToCheck the byte to check
* @return true if byte is whitespace, false otherwise
*/
private static boolean isWhiteSpace(final byte byteToCheck) {
switch (byteToCheck) {
case ' ':
case '\n':
case '\r':
case '\t':
return true;
default:
return false;
}
}
private static String newStringUtf8(final byte[] encode) {
return new String(encode, StandardCharsets.UTF_8);
}
/**
* Returns a byte-array representation of a BigInteger without sign bit.
*
* @param bigInt BigInteger to be converted
* @return a byte array representation of the BigInteger parameter
*/
static byte[] toIntegerBytes(final BigInteger bigInt) {
Objects.requireNonNull(bigInt, "bigInt");
int bitlen = bigInt.bitLength();
// round bitlen
bitlen = ((bitlen + 7) >> 3) << 3;
final byte[] bigBytes = bigInt.toByteArray();
if (((bigInt.bitLength() % 8) != 0) && (((bigInt.bitLength() / 8) + 1) == (bitlen / 8))) {
return bigBytes;
}
// set up params for copying everything but sign bit
int startSrc = 0;
int len = bigBytes.length;
// if bigInt is exactly byte-aligned, just skip signbit in copy
if ((bigInt.bitLength() % 8) == 0) {
startSrc = 1;
len--;
}
final int startDst = bitlen / 8 - len; // to pad w/ nulls as per spec
final byte[] resizedBytes = new byte[bitlen / 8];
System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
return resizedBytes;
}
/**
* Encode table to use: either STANDARD or URL_SAFE. Note: the DECODE_TABLE above remains static because it is able to decode both STANDARD and URL_SAFE
* streams, but the encodeTable must be a member variable so we can switch between the two modes.
*/
private final byte[] encodeTable;
/**
* Line length for encoding. Not used when decoding. A value of zero or less implies no chunking of the base64 encoded data.
*/
private final int lineLength;
/**
* Line separator for encoding. Not used when decoding. Only used if lineLength > 0.
*/
private final byte[] lineSeparator;
/**
* Convenience variable to help us determine when our buffer is going to run out of room and needs resizing.
* decodeSize = 3 + lineSeparator.length;
*/
private final int decodeSize;
/**
* Convenience variable to help us determine when our buffer is going to run out of room and needs resizing.
* encodeSize = 4 + lineSeparator.length;
*/
private final int encodeSize;
/**
* Buffer for streaming.
*/
private byte[] buffer;
/**
* Position where next character should be written in the buffer.
*/
private int pos;
/**
* Position where next character should be read from the buffer.
*/
private int readPos;
/**
* Variable tracks how many characters have been written to the current line. Only used when encoding. We use it to make sure each encoded line never goes
* beyond lineLength (if lineLength > 0).
*/
private int currentLinePos;
/**
* Writes to the buffer only occur after every 3 reads when encoding, an every 4 reads when decoding. This variable helps track that.
*/
private int modulus;
/**
* Boolean flag to indicate the EOF has been reached. Once EOF has been reached, this Base64 object becomes useless, and must be thrown away.
*/
private boolean eof;
/**
* Place holder for the 3 bytes we're dealing with for our base64 logic. Bitwise operations store and extract the base64 encoding or decoding from this
* variable.
*/
private int x;
/**
* Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
* true, URL-safe encoding is used. In most cases this should be set to false.
* @since 1.4
*/
public Base64(final boolean urlSafe) {
this(CHUNK_SIZE, CHUNK_SEPARATOR, urlSafe);
}
/**
* Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
*
* KeyManager km = KeyManagerUtils.createClientKeyManager("JKS",
* "/path/to/privatekeystore.jks","storepassword",
* "privatekeyalias", "keypassword");
* FTPSClient cl = new FTPSClient();
* cl.setKeyManager(km);
* cl.connect(...);
*
*
* If using the default store type and the key password is the same as the store password, these parameters can be omitted.
* If the desired key is the first or only key in the keystore, the keyAlias parameter can be omitted, in which case the code becomes:
*
*
* KeyManager km = KeyManagerUtils.createClientKeyManager(
* "/path/to/privatekeystore.jks","storepassword");
* FTPSClient cl = new FTPSClient();
* cl.setKeyManager(km);
* cl.connect(...);
*
*
* @since 3.0
*/
public final class KeyManagerUtils {
private static class ClientKeyStore {
private final X509Certificate[] certChain;
private final PrivateKey key;
private final String keyAlias;
ClientKeyStore(final KeyStore ks, final String keyAlias, final String keyPass) throws GeneralSecurityException {
this.keyAlias = keyAlias;
this.key = (PrivateKey) ks.getKey(this.keyAlias, keyPass.toCharArray());
final Certificate[] certs = ks.getCertificateChain(this.keyAlias);
final X509Certificate[] x509certs = new X509Certificate[certs.length];
Arrays.setAll(x509certs, i -> (X509Certificate) certs[i]);
this.certChain = x509certs;
}
final String getAlias() {
return this.keyAlias;
}
final X509Certificate[] getCertificateChain() {
return this.certChain;
}
final PrivateKey getPrivateKey() {
return this.key;
}
}
private static class X509KeyManager extends X509ExtendedKeyManager {
private final ClientKeyStore keyStore;
X509KeyManager(final ClientKeyStore keyStore) {
this.keyStore = keyStore;
}
// Call sequence: 1
@Override
public String chooseClientAlias(final String[] keyType, final Principal[] issuers, final Socket socket) {
return keyStore.getAlias();
}
@Override
public String chooseServerAlias(final String keyType, final Principal[] issuers, final Socket socket) {
return null;
}
// Call sequence: 2
@Override
public X509Certificate[] getCertificateChain(final String alias) {
return keyStore.getCertificateChain();
}
@Override
public String[] getClientAliases(final String keyType, final Principal[] issuers) {
return new String[] { keyStore.getAlias() };
}
// Call sequence: 3
@Override
public PrivateKey getPrivateKey(final String alias) {
return keyStore.getPrivateKey();
}
@Override
public String[] getServerAliases(final String keyType, final Principal[] issuers) {
return null;
}
}
private static final String DEFAULT_STORE_TYPE = KeyStore.getDefaultType();
/**
* Create a client key manager which returns a particular key. Does not handle server keys. Uses the default store type and assumes the key password is the
* same as the store password. The key alias is found by searching the keystore for the first private key entry
*
* @param storePath the path to the keyStore
* @param storePass the keyStore password
* @return the customised KeyManager
* @throws IOException if there is a problem creating the keystore
* @throws GeneralSecurityException if there is a problem creating the keystore
*/
public static KeyManager createClientKeyManager(final File storePath, final String storePass) throws IOException, GeneralSecurityException {
return createClientKeyManager(DEFAULT_STORE_TYPE, storePath, storePass, null, storePass);
}
/**
* Create a client key manager which returns a particular key. Does not handle server keys. Uses the default store type and assumes the key password is the
* same as the store password
*
* @param storePath the path to the keyStore
* @param storePass the keyStore password
* @param keyAlias the alias of the key to use, may be {@code null} in which case the first key entry alias is used
* @return the customised KeyManager
* @throws IOException if there is a problem creating the keystore
* @throws GeneralSecurityException if there is a problem creating the keystore
*/
public static KeyManager createClientKeyManager(final File storePath, final String storePass, final String keyAlias)
throws IOException, GeneralSecurityException {
return createClientKeyManager(DEFAULT_STORE_TYPE, storePath, storePass, keyAlias, storePass);
}
/**
* Create a client key manager which returns a particular key. Does not handle server keys.
*
* @param ks the keystore to use
* @param keyAlias the alias of the key to use, may be {@code null} in which case the first key entry alias is used
* @param keyPass the password of the key to use
* @return the customised KeyManager
* @throws GeneralSecurityException if there is a problem creating the keystore
*/
public static KeyManager createClientKeyManager(final KeyStore ks, final String keyAlias, final String keyPass) throws GeneralSecurityException {
final ClientKeyStore cks = new ClientKeyStore(ks, keyAlias != null ? keyAlias : findAlias(ks), keyPass);
return new X509KeyManager(cks);
}
/**
* Create a client key manager which returns a particular key. Does not handle server keys.
*
* @param storeType the type of the keyStore, e.g. "JKS"
* @param storePath the path to the keyStore
* @param storePass the keyStore password
* @param keyAlias the alias of the key to use, may be {@code null} in which case the first key entry alias is used
* @param keyPass the password of the key to use
* @return the customised KeyManager
* @throws GeneralSecurityException if there is a problem creating the keystore
* @throws IOException if there is a problem creating the keystore
*/
public static KeyManager createClientKeyManager(final String storeType, final File storePath, final String storePass, final String keyAlias,
final String keyPass) throws IOException, GeneralSecurityException {
final KeyStore ks = loadStore(storeType, storePath, storePass);
return createClientKeyManager(ks, keyAlias, keyPass);
}
private static String findAlias(final KeyStore ks) throws KeyStoreException {
final Enumerationaddress is in the range of usable endpoint addresses for this subnet. This excludes the network and broadcast
* addresses by default. Use {@link SubnetUtils#setInclusiveHostCount(boolean)} to change this.
*
* @param address the address to check
* @return true if it is in range
* @since 3.4 (made public)
*/
public boolean isInRange(final int address) {
if (address == 0) { // cannot ever be in range; rejecting now avoids problems with CIDR/31,32
return false;
}
final long addLong = address & UNSIGNED_INT_MASK;
final long lowLong = low() & UNSIGNED_INT_MASK;
final long highLong = high() & UNSIGNED_INT_MASK;
return addLong >= lowLong && addLong <= highLong;
}
/**
* Tests if the parameter address is in the range of usable endpoint addresses for this subnet. This excludes the network and broadcast
* addresses. Use {@link SubnetUtils#setInclusiveHostCount(boolean)} to change this.
*
* @param address A dot-delimited IPv4 address, e.g. "192.168.0.1"
* @return True if in range, false otherwise
*/
public boolean isInRange(final String address) {
return isInRange(toInteger(address));
}
private int low() {
return isInclusiveHostCount() ? network : broadcastLong() - networkLong() > 1 ? network + 1 : 0;
}
/** long versions of the values (as unsigned int) which are more suitable for range checking. */
private long networkLong() {
return network & UNSIGNED_INT_MASK;
}
/**
* Converts a packed integer address into a 4-element array
*/
private int[] toArray(final int val) {
final int ret[] = new int[4];
for (int j = 3; j >= 0; --j) {
ret[j] |= val >>> 8 * (3 - j) & 0xff;
}
return ret;
}
/**
* {@inheritDoc}
*
* @since 2.2
*/
@Override
public String toString() {
final StringBuilder buf = new StringBuilder();
// @formatter:off
buf.append("CIDR Signature:\t[").append(getCidrSignature()).append("]\n")
.append(" Netmask: [").append(getNetmask()).append("]\n")
.append(" Network: [").append(getNetworkAddress()).append("]\n")
.append(" Broadcast: [").append(getBroadcastAddress()).append("]\n")
.append(" First address: [").append(getLowAddress()).append("]\n")
.append(" Last address: [").append(getHighAddress()).append("]\n")
.append(" Address Count: [").append(getAddressCountLong()).append("]\n");
// @formatter:on
return buf.toString();
}
}
private static final String IP_ADDRESS = "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})";
private static final String SLASH_FORMAT = IP_ADDRESS + "/(\\d{1,2})"; // 0 -> 32
private static final Pattern ADDRESS_PATTERN = Pattern.compile(IP_ADDRESS);
private static final Pattern CIDR_PATTERN = Pattern.compile(SLASH_FORMAT);
private static final int NBITS = 32;
private static final String PARSE_FAIL = "Could not parse [%s]";
/*
* Extracts the components of a dotted decimal address and pack into an integer using a regex match
*/
private static int matchAddress(final Matcher matcher) {
int addr = 0;
for (int i = 1; i <= 4; ++i) {
final int n = rangeCheck(Integer.parseInt(matcher.group(i)), 0, 255);
addr |= (n & 0xff) << 8 * (4 - i);
}
return addr;
}
/*
* Checks integer boundaries. Checks if a value x is in the range [begin,end]. Returns x if it is in range, throws an exception otherwise.
*/
private static int rangeCheck(final int value, final int begin, final int end) {
if (value >= begin && value <= end) { // (begin,end]
return value;
}
throw new IllegalArgumentException("Value [" + value + "] not in range [" + begin + "," + end + "]");
}
/*
* Converts a dotted decimal format address to a packed integer format
*/
private static int toInteger(final String address) {
final Matcher matcher = ADDRESS_PATTERN.matcher(address);
if (matcher.matches()) {
return matchAddress(matcher);
}
throw new IllegalArgumentException(String.format(PARSE_FAIL, address));
}
private final int netmask;
private final int address;
private final int network;
private final int broadcast;
/** Whether the broadcast/network address are included in host count */
private boolean inclusiveHostCount;
/**
* Constructs an instance from a CIDR-notation string, e.g. "192.168.0.1/16"
*
* @param cidrNotation A CIDR-notation string, e.g. "192.168.0.1/16"
* @throws IllegalArgumentException if the parameter is invalid, i.e. does not match n.n.n.n/m where n=1-3 decimal digits, m = 1-2 decimal digits in range
* 0-32
*/
public SubnetUtils(final String cidrNotation) {
final Matcher matcher = CIDR_PATTERN.matcher(cidrNotation);
if (!matcher.matches()) {
throw new IllegalArgumentException(String.format(PARSE_FAIL, cidrNotation));
}
this.address = matchAddress(matcher);
// Create a binary netmask from the number of bits specification /x
final int trailingZeroes = NBITS - rangeCheck(Integer.parseInt(matcher.group(5)), 0, NBITS);
//
// An IPv4 netmask consists of 32 bits, a contiguous sequence
// of the specified number of ones followed by all zeros.
// So, it can be obtained by shifting an unsigned integer (32 bits) to the left by
// the number of trailing zeros which is (32 - the # bits specification).
// Note that there is no unsigned left shift operator, so we have to use
// a long to ensure that the left-most bit is shifted out correctly.
//
this.netmask = (int) (0x0FFFFFFFFL << trailingZeroes);
// Calculate base network address
this.network = address & netmask;
// Calculate broadcast address
this.broadcast = network | ~netmask;
}
/**
* Constructs an instance from a dotted decimal address and a dotted decimal mask.
*
* @param address An IP address, e.g. "192.168.0.1"
* @param mask A dotted decimal netmask e.g. "255.255.0.0"
* @throws IllegalArgumentException if the address or mask is invalid, i.e. does not match n.n.n.n where n=1-3 decimal digits and the mask is not all zeros
*/
public SubnetUtils(final String address, final String mask) {
this.address = toInteger(address);
this.netmask = toInteger(mask);
if ((this.netmask & -this.netmask) - 1 != ~this.netmask) {
throw new IllegalArgumentException(String.format(PARSE_FAIL, mask));
}
// Calculate base network address
this.network = this.address & this.netmask;
// Calculate broadcast address
this.broadcast = this.network | ~this.netmask;
}
/**
* Gets a {@link SubnetInfo} instance that contains subnet-specific statistics
*
* @return new instance
*/
public final SubnetInfo getInfo() {
return new SubnetInfo();
}
public SubnetUtils getNext() {
return new SubnetUtils(getInfo().getNextAddress(), getInfo().getNetmask());
}
public SubnetUtils getPrevious() {
return new SubnetUtils(getInfo().getPreviousAddress(), getInfo().getNetmask());
}
/**
* Tests if the return value of {@link SubnetInfo#getAddressCount()} includes the network and broadcast addresses.
*
* @since 2.2
* @return true if the host count includes the network and broadcast addresses
*/
public boolean isInclusiveHostCount() {
return inclusiveHostCount;
}
/**
* Sets to true if you want the return value of {@link SubnetInfo#getAddressCount()} to include the network and broadcast addresses. This also
* applies to {@link SubnetInfo#isInRange(int)}
*
* @param inclusiveHostCount true if network and broadcast addresses are to be included
* @since 2.2
*/
public void setInclusiveHostCount(final boolean inclusiveHostCount) {
this.inclusiveHostCount = inclusiveHostCount;
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/util/TrustManagerUtils.java 0000664 0000000 0000000 00000007475 14340477222 0033203 0 ustar 00root root 0000000 0000000 /*
* 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.util;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
/**
* TrustManager utilities for generating TrustManagers.
*
* @since 3.0
*/
public final class TrustManagerUtils {
private static class TrustManager implements X509TrustManager {
private final boolean checkServerValidity;
TrustManager(final boolean checkServerValidity) {
this.checkServerValidity = checkServerValidity;
}
/**
* Never generates a CertificateException.
*/
@Override
public void checkClientTrusted(final X509Certificate[] certificates, final String authType) {
}
@Override
public void checkServerTrusted(final X509Certificate[] certificates, final String authType) throws CertificateException {
if (checkServerValidity) {
for (final X509Certificate certificate : certificates) {
certificate.checkValidity();
}
}
}
/**
* @return an empty array of certificates
*/
@Override
public X509Certificate[] getAcceptedIssuers() {
return NetConstants.EMPTY_X509_CERTIFICATE_ARRAY;
}
}
private static final X509TrustManager ACCEPT_ALL = new TrustManager(false);
private static final X509TrustManager CHECK_SERVER_VALIDITY = new TrustManager(true);
/**
* Generate a TrustManager that performs no checks.
*
* @return the TrustManager
*/
public static X509TrustManager getAcceptAllTrustManager() {
return ACCEPT_ALL;
}
/**
* Return the default TrustManager provided by the JVM.
*
* WhoisClient whois;
*
* whois = new WhoisClient();
*
* try {
* whois.connect(WhoisClient.DEFAULT_HOST);
* System.out.println(whois.query("foobar"));
* whois.disconnect();
* } catch (IOException e) {
* System.err.println("Error I/O exception: " + e.getMessage());
* return;
* }
*
*
*
*
*/
public final class WhoisClient extends FingerClient {
/**
* The default whois host to query. It is set to whois.internic.net.
*/
public static final String DEFAULT_HOST = "whois.internic.net";
/**
* The default whois port. It is set to 43 according to RFC 954.
*/
public static final int DEFAULT_PORT = 43;
/**
* The default whois constructor. Initializes the default port to DEFAULT_PORT .
*/
public WhoisClient() {
setDefaultPort(DEFAULT_PORT);
}
/**
* Queries the connected whois server for information regarding the given handle and returns the InputStream of the network connection. It is up to the
* programmer to be familiar with the handle syntax of the whois server. You must first connect to a finger server before calling this method, and you
* should disconnect after finishing reading the stream.
*
* @param handle The handle to lookup.
* @return The InputStream of the network connection of the whois query. Can be read to obtain whois results.
* @throws IOException If an I/O error occurs during the operation.
*/
public InputStream getInputStream(final String handle) throws IOException {
return getInputStream(false, handle);
}
/**
* Queries the connected whois server for information regarding the given handle. It is up to the programmer to be familiar with the handle syntax of the
* whois server. You must first connect to a whois server before calling this method, and you should disconnect afterward.
*
* @param handle The handle to lookup.
* @return The result of the whois query.
* @throws IOException If an I/O error occurs during the operation.
*/
public String query(final String handle) throws IOException {
return query(false, handle);
}
}
commons-net-rel-commons-net-3.9.0/src/main/java/org/apache/commons/net/whois/package-info.java 0000664 0000000 0000000 00000001541 14340477222 0032232 0 ustar 00root root 0000000 0000000 /*
* 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.
*/
/**
* Whois client
*/
package org.apache.commons.net.whois; commons-net-rel-commons-net-3.9.0/src/main/resources/ 0000775 0000000 0000000 00000000000 14340477222 0022531 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/resources/org/ 0000775 0000000 0000000 00000000000 14340477222 0023320 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/resources/org/apache/ 0000775 0000000 0000000 00000000000 14340477222 0024541 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/resources/org/apache/commons/ 0000775 0000000 0000000 00000000000 14340477222 0026214 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/resources/org/apache/commons/net/ 0000775 0000000 0000000 00000000000 14340477222 0027002 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/resources/org/apache/commons/net/examples/ 0000775 0000000 0000000 00000000000 14340477222 0030620 5 ustar 00root root 0000000 0000000 examples.properties 0000664 0000000 0000000 00000006324 14340477222 0034502 0 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/main/resources/org/apache/commons/net/examples ################################################################################
# Apache Commons Net Examples Property file
################################################################################
## 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.
# List of aliases for example class names.
# alias full class name
SubnetUtilsExample org.apache.commons.net.examples.cidr.SubnetUtilsExample
FTPClientExample org.apache.commons.net.examples.ftp.FTPClientExample
ServerToServerFTP org.apache.commons.net.examples.ftp.ServerToServerFTP
TFTPExample org.apache.commons.net.examples.ftp.TFTPExample
IMAPExportMbox org.apache.commons.net.examples.mail.IMAPExportMbox
IMAPImportMbox org.apache.commons.net.examples.mail.IMAPImportMbox
IMAPMail org.apache.commons.net.examples.mail.IMAPMail
POP3ExportMbox org.apache.commons.net.examples.mail.POP3ExportMbox
POP3Mail org.apache.commons.net.examples.mail.POP3Mail
SMTPMail org.apache.commons.net.examples.mail.SMTPMail
ArticleReader org.apache.commons.net.examples.nntp.ArticleReader
ExtendedNNTPOps org.apache.commons.net.examples.nntp.ExtendedNNTPOps
ListNewsgroups org.apache.commons.net.examples.nntp.ListNewsgroups
MessageThreading org.apache.commons.net.examples.nntp.MessageThreading
PostMessage org.apache.commons.net.examples.nntp.PostMessage
NTPClient org.apache.commons.net.examples.ntp.NTPClient
SimpleNTPServer org.apache.commons.net.examples.ntp.SimpleNTPServer
TimeClient org.apache.commons.net.examples.ntp.TimeClient
TelnetClientExample org.apache.commons.net.examples.telnet.TelnetClientExample
WeatherTelnet org.apache.commons.net.examples.telnet.WeatherTelnet
chargen org.apache.commons.net.examples.unix.chargen
daytime org.apache.commons.net.examples.unix.daytime
echo org.apache.commons.net.examples.unix.echo
finger org.apache.commons.net.examples.unix.finger
fwhois org.apache.commons.net.examples.unix.fwhois
rdate org.apache.commons.net.examples.unix.rdate
rexec org.apache.commons.net.examples.unix.rexec
rlogin org.apache.commons.net.examples.unix.rlogin
rshell org.apache.commons.net.examples.unix.rshell
commons-net-rel-commons-net-3.9.0/src/media/ 0000775 0000000 0000000 00000000000 14340477222 0020652 5 ustar 00root root 0000000 0000000 commons-net-rel-commons-net-3.9.0/src/media/net-logo-white.xcf 0000664 0000000 0000000 00000047163 14340477222 0024231 0 ustar 00root root 0000000 0000000 gimp xcf file Q B B L K
gimp-comment Created with The GIMP gimp-image-grid (style solid)
(fgcolor (color-rgba 0.000000 0.000000 0.000000 1.000000))
(bgcolor (color-rgba 1.000000 1.000000 1.000000 1.000000))
(xspacing 10.000000)
(yspacing 10.000000)
(spacing-unit inches)
(xoffset 0.000000)
(yoffset 0.000000)
(offset-unit inches)
0 & E #m L TM
C L 8 gimp-text-layer (text "TM")
(font "Sans")
(font-size 8.000000)
(font-size-unit pixels)
(hinting yes)
(antialias yes)
(language "en-us")
(base-direction ltr)
(color (color-rgb 0.000000 0.000000 0.000000))
(justify left)
(box-mode fixed)
(box-width 12.000000)
(box-height 11.000000)
(box-unit pixels)
# ɰ- > 8x 88w 8P 8? 8 4 net
& J 4 4 H H H - U 0 8 0 ƪ / U . - q U8
8qU qUU U 8 UU U q U8 q U qq 8 8U q U U UU U U U U U U U U U U 8 8 U 8 U 8 U 88 U qUU8 q q U U qU 8 U 8 88 q 8 R 8 Drop-Shadow#2
K R 8 9 R 8 6 3 .
!##" #&)+,+*'# !! !"#%(+.1331-( "$&'())('&#! !#$%&'(*+-0369;;:84. !%),.0112210.,)&$! !#$&(*+-./01358;>ABCB>:4
"',04689::98641.,)(''()*,.02356789;=?BEGIIGD>8 '-37;>?@AA@><96410//023579:<=>?@ACFHKMONLHB; $,29>BDFGGHGECA><987789:<=?@BCDEFGIKMPRSRPKE=
(07>CGIKKLLKJHFCA@??@ABCDEFGHIJKLNQSUUTRMF>
"*3:AGKMNNOPONLJHGFFGHIJJKLLMOPRUVWVSNG?
$,5=DJMOPPQRSTSSRPONMMLLKLMNOQSUVWVSNG>
%.6?FKNPQPPQSTVWWVUUTSSRRQPOMLLKKLNPRTUVURMF>
%.7?FLOPQPOOPQSUWYYZYYXXWWVTSQOMKJJIIJKMPRTUTQLE= &.7@FLOPPONNPRUXZ[\]]\\[YXURPMKIGFFGHKMPRSSPKD< &/7?FKNONMLLMNQTXZ\^__^\ZWTPMJGEDCCDEHKNPRQOKD< %.7?EJMMKJJKMPSWZ\^_`aa``^\YUQMIFCA@@ABEHKNPPNJD<
%.6>DIKLKJHHIKNQUY\^_`aa_]ZVRMIEB?>=>?BEILNNMIC<
$-5=CGJJIHFFGILPTWZ\^_`aa`^[WSNIEA><;;=?BFILMLHC<
$,4;AFHHGFDDGJMQUXZ\]^__][XSOJEA>;:9:=@DGJKJGB<
#+3:?CEFECBABDGJNRTVXYZ[\]]\ZWTOKFA>:988:=ADGIHFA;
!)07=@BBA@?>?ACGJMPRSTUWXYYXVSOJFA=97667:=ADEEC?:
'.49=>?><;;=?BEHJLMNOPRSTUTSQMIE@<854347:=@BB@=8 $*058::987678:=@BDEFGHIKMNOOMJFB>:63100258;<=<94 &,034432123579;=>>?@ACEFHIHGEB>:62/-,,-02577640
"'*-..-,,-/124566778:<>?@A@><951-*('&(),.010.+ !$&'('&&%&'()+,--./1246788752/+(%"!!"#%')*)(%
!! !"#$%%&()+-.//.-*(%" ""!
!"$%&&%#
#
(! ,% 0(
3*"
4+#
5,#
5,#
5," 4+"
4*!
3*!
3*!
3*"
3+" 4+#
4+#
4,$ 3+# 1*# /(! +%
&!
!
h ) commons
#U #a ! & $ ! 8qU 8Uq8 q8 q q
UU 88 U U8 qU qU U U qU U U q UU q 8 U 8 U U 8 q8 U 8 q 8 U 8 U U U U U
U U
8 U U U
8 88 U q 88 88 q 8 q 8 q UUUU U q U U U U U U
8q U q
q8 Uq UU 8qU
8q8 U8
8 Uq U 8 q q q 8 8 q qUUq UUUq ƪ UqUU UU8 U qq
q8 UU U 8 8U Uq q
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU
UU UU qU q qU q U 8qU8 8qU8 UƍU UU U8 q q q q8
8 q UU 88 qU 88 8U U U U UU 8U 8 U UUU U U U UU 8 q
8 Uq UU U
UU UU U
8 UU UU
U UU UU
UU UU
UU UU
U UU UU U U UU UU U U UU UU UU UU UU U UU UU 8
UU UU
q UU UU q UU UU q 8 UU UU U UU Uq U qU 8 8U UqqU 8q 8qU U
8 Uq8 q 8V V V
UU ⪪ 8 8 8 8 8 U q qq 8 8
q 8 qU
q U q q 8 q ƪq 8 8 8UU k
5 8 Drop-Shadow
9 $ 8 $1 Lx L 8 $M . 9J D! U
!#$%%$# !"##$%%$" "$&')*+,,+*'%" !#$&'())*+,,*(&#! !$&(*+-.01221.,)&#! !#$'(*+,--./0234431.,) #'),-/01346787642/,)(''(*,./11223568:;;9752
!&*-/12334679:;<;9742/..0245677665668:=?ABCB@=:
"',02456678:<=>>=;97544579;<==<:9878:>=;:99:<>ABCCB@=;988:=@EIMOPONK
&-38;==<:8655679;<=>==>@BEGIIHFC?;9779<@FKPSUVTR $+29=@AA>;853223579:;<==?ADGKMOOMJE@;7556:?EKQVZ[ZX
(08>CEED@<830..024689;=@CGLPSTSQLGA;63237=CKRX\__]
$,5=CGJIGB=72.+))*,.1369<@EJOTWXWTOHA:40/04:AJRY^aba '09AHLNMID>71+(%%'),/26:@FLRW[\[WQIA93.,-17?HQY_cdd )3=ELPRPLF?70*%"!!"$'*.38?FMTZ^_^YSJA92-*+/5=FOX_dfe ",6@HOTUSOIA81*$! !#'+06>ENU\`a`[TKB91,))-3;DNW^cff
#-8BKSWYWRLC;2+% !$(.5-z܊dAPcMyUN/\P
ܦW^b =EZ v|5۹-t[()`\>B;4(|~J éJ,9frZC2 []$8K5dжrfR2H9% .jL=2gqjO.(?r`rꗴ$ zךt½XhGZ'ŨJ)܊[im& R
t?i%ӎ;2$ytly[%˜si۵ Iha4HrP`߸c,7yXg/t U ~>L)^z[T *CW|էab rc EOӏޤEZ"wJΆu[SD"y |CmW^B+%e6
8]O ޯ:L"M,1y/R5 0%&