All Classes and Interfaces
Class
Description
This is a class that contains the basic state needed for message retrieval and threading.
Class contains details about an article.
Class which wraps an
Iterable<String> of raw article information to generate an Iterable<Article> of the parsed information.Deprecated.
Sample program demonstrating the use of article header and body retrieval
An IMAP Client class with authentication support.
The enumeration of currently-supported authentication methods.
An SMTP Client class with authentication support (RFC4954).
The enumeration of currently-supported authentication methods.
Deprecated.
Use
Base64.This is an example program demonstrating how to use the CharGenTCPClient and CharGenUDPClient classes.
The CharGenTCPClient class is a TCP implementation of a client for the character generator protocol described in RFC 864.
The CharGenUDPClient class is a UDP implementation of a client for the character generator protocol described in RFC 864.
Helps to deal with Charsets.
This implementation allows to pack some FileEntryParsers together and handle the case where the returned dir style isn't clearly defined.
This interface adds the aspect of configurability by means of a supplied FTPClientConfig object to other classes in the system, especially listing parsers.
This abstract class implements the common timestamp parsing algorithm for all the concrete parsers.
The CopyStreamAdapter will relay CopyStreamEvents to a list of listeners when either of its bytesTransferred() methods are called.
A CopyStreamEvent is triggered after every write performed by a stream copying operation.
The CopyStreamException class is thrown by the org.apache.commons.io.Util copyStream() methods.
The CopyStreamListener class can accept CopyStreamEvents to keep track of the progress of a stream copying operation.
CRLFLineReader implements a readLine() method that requires exactly CRLF to terminate an input line.
The DatagramSocketClient provides the basic operations that are required of client objects accessing datagram sockets.
The DatagramSocketFactory interface provides a means for the programmer to control the creation of datagram sockets and provide his own DatagramSocket
implementations for use by all classes derived from
DatagramSocketClient .This is an example program demonstrating how to use the DaytimeTCP and DaytimeUDP classes.
The DaytimeTCPClient class is a TCP implementation of a client for the Daytime protocol described in RFC 867.
The DaytimeUDPClient class is a UDP implementation of a client for the Daytime protocol described in RFC 867.
Implements the DatagramSocketFactory interface by simply wrapping the
DatagramSocket constructors.This is the default implementation of the FTPFileEntryParserFactory interface.
DefaultSocketFactory implements the SocketFactory interface by simply wrapping the java.net.Socket and java.net.ServerSocket constructors.
Wrapper class for FTP data channel sockets when compressing data in the "deflate" compression format.
Wrapper class for FTP data channel sockets.
The DiscardTCPClient class is a TCP implementation of a client for the Discard protocol described in RFC 863.
The DiscardUDPClient class is a UDP implementation of a client for the Discard protocol described in RFC 863.
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 beginning of lines which do not signal end of message yet start with a dot.
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 beginning of lines which do not signal end of message yet start with a dot.
Temporary until Commons Lang 3.12.0.
This is an example program demonstrating how to use the EchoTCPClient and EchoUDPClient classes.
Implements the telnet echo option RFC 857.
The EchoTCPClient class is a TCP implementation of a client for the Echo protocol described in RFC 862.
The EchoUDPClient class is a UDP implementation of a client for the Echo protocol described in RFC 862.
Parser for the Connect Enterprise UNIX FTP Server From Sterling Commerce.
Simple class showing some of the extended commands (AUTH, XOVER, LIST ACTIVE)
A POP3 Cilent class with protocol and authentication extensions support (RFC2449 and RFC2195).
The enumeration of currently-supported authentication methods.
This is an example of how you would implement the finger command in Java using NetComponents.
The FingerClient class implements the client side of the Internet Finger Protocol defined in RFC 1288.
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.
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.
FTP provides the basic the functionality necessary to implement your own FTP client.
FTPClient encapsulates all the functionality necessary to store and retrieve files from an FTP server.
Strategy interface for updating host names received from FTP server for passive NAT workaround.
Default strategy for passive NAT workaround (site-local replies are replaced.)
This class implements an alternate means of configuring the
FTPClient object and also subordinate objects which
it uses.This is an example program demonstrating how to use the FTPClient class.
Deprecated.
use
FTPCmd insteadFTPConnectionClosedException is used to indicate the premature or unexpected closing of an FTP connection resulting from a
FTPReply.SERVICE_NOT_AVAILABLE response (FTP reply code 421) to a failed FTP command.The FTPFile class is used to represent information about files stored on an FTP server.
FTPFileEntryParser defines the interface for parsing a single FTP file listing and converting that information into an
FTPFile instance.The interface describes a factory for creating FTPFileEntryParsers.
This abstract class implements both the older FTPFileListParser and newer FTPFileEntryParser interfaces with default functionality.
Performs filtering on
FTPFile instances.Implements some simple FTPFileFilter classes.
Experimental attempt at FTP client that tunnels over an HTTP proxy connection.
This class handles the entire process of parsing a listing of file entries from the server.
FTPReply stores a set of constants for FTP reply codes.
FTP over SSL processing.
Deprecated.
3.0 DO NOT USE
Server socket factory for FTPS connections.
Socket factory for FTPS connections.
Deprecated.
3.0 use
TrustManagerUtils#getValidateServerCertificateTrustManager() insteadThis interface specifies the concept of parsing an FTP server's timestamp.
Default implementation of the
FTPTimestampParser interface also implements the Configurable interface to allow the parsing to be configured from the outside.This is an example of how you would implement the Linux fwhois command in Java using NetComponents.
The IMAP class provides the basic the functionality necessary to implement your own IMAP client.
Implement this interface and register it via
IMAP.setChunkListener(IMAPChunkListener) in order to get access to multi-line partial command responses.The IMAPClient class provides the basic functionalities found in an IMAP client.
The message data item names for the FETCH command defined in RFC 3501.
The search criteria defined in RFC 3501.
The status data items defined in RFC 3501.
IMAPCommand stores IMAP command codes.
This is an example program demonstrating how to use the IMAP[S]Client class.
This is an example program demonstrating how to use the IMAP[S]Client class.
This is an example program demonstrating how to use the IMAP[S]Client class.
Stores IMAP reply code constants.
The IMAPSClient class provides SSL/TLS connection encryption to IMAPClient.
Utility class for shared IMAP utilities
The InvalidTelnetOptionException is the exception that is thrown whenever a TelnetOptionHandler with an invlaid option code is registered in TelnetClient
with addOptionHandler.
This is a utility class providing a reader/writer capability required by the weatherTelnet, rexec, rshell, and rlogin example programs.
General KeyManager utilities
This is a trivial example using the NNTP package to approximate the UNIX newsgroups command.
Implementation FTPFileEntryParser and FTPFileListParser for pre MacOS-X Systems.
Helper application for example classes.
This exception is used to indicate that the reply from a server could not be interpreted.
Sample program demonstrating the use of article iteration and threading.
Parser class for MSLT and MLSD replies.
Implements
FTPFileEntryParser and Configurable for IBM zOS/MVS Systems.Constants provided as public only for our own implementation, you can consider this private for now.
Implements
FTPFileEntryParser and Configurable for Netware Systems.The NewGroupsOrNewsQuery class.
NewsgroupInfo stores information pertaining to a newsgroup returned by the NNTP GROUP, LIST, and NEWGROUPS commands, implemented by
selectNewsgroup , listNewsgroups , and listNewNewsgroups respectively.Class which wraps an
Iterable<String> of raw newgroup information to generate an Iterable<NewsgroupInfo> of the parsed information.The NNTP class is not meant to be used by itself and is provided only so that you may easily implement your own NNTP client if you so desire.
NNTPClient encapsulates all the functionality necessary to post and retrieve articles from an NNTP server.
NNTPCommand stores a set of constants for NNTP command codes.
NNTPConnectionClosedException is used to indicate the premature or unexpected closing of an NNTP connection resulting from a
NNTPReply.SERVICE_DISCONTINUED response (NNTP reply code 400) to a failed NNTP command.NNTPReply stores a set of constants for NNTP reply codes.
A placeholder utility class, used for constructing a tree of Threadables Original implementation by Jamie Zawinski.
Some convenience methods for NNTP example classes.
Implements
FTPFileEntryParser and Configurable for NT Systems.This is an example program demonstrating how to use the NTPUDPClient class.
The NTPUDPClient class is a UDP implementation of a client for the Network Time Protocol (NTP) described in RFC 1305 as well as the Simple Network Time
Protocol (SNTP) in RFC-2030.
Common NtpUtils Helper class.
Implements
NtpV3Packet to convert Java objects to and from the Network Time Protocol (NTP) data message header format described in RFC-1305.Interface for a NtpV3Packet with get/set methods corresponding to the fields in the NTP Data Message Header described in RFC 1305.
Implements of
FTPFileEntryParser and Configurable for OS/2 Systems.
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.
This class encapsulates all errors that may be thrown by the process of an FTPFileEntryParserFactory creating and instantiating an FTPFileEntryParser.
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.
The POP3Client class implements the client side of the Internet POP3 Protocol defined in RFC 1939.
POP3Command stores POP3 command code constants.
This is an example program demonstrating how to use the POP3[S]Client class.
This is an example program demonstrating how to use the POP3[S]Client class.
POP3MessageInfo is used to return information about messages stored on a POP3 server.
POP3Reply stores POP3 reply code constants.
POP3 over SSL processing.
This is an example program using the NNTP package to post an article to the specified newsgroup(s).
This is a support class for some example programs.
There exists a large class of IETF protocols that work by sending an ASCII text command and arguments to a server, and then receiving an ASCII text reply.
There exists a large class of IETF protocols that work by sending an ASCII text command and arguments to a server, and then receiving an ASCII text reply.
ProtocolCommandSupport is a convenience class for managing a list of ProtocolCommandListeners and firing ProtocolCommandEvents.
RCommandClient is very similar to
RExecClient, from which it is derived, and implements the rcmd() facility that first
appeared in 4.2BSD Unix.This is an example program demonstrating how to use the TimeTCPClient and TimeUDPClient classes.
This abstract class implements both the older FTPFileListParser and newer FTPFileEntryParser interfaces with default functionality.
A class used to represent forward and reverse relay paths.
Wraps a
BufferedReader and returns an Iterable<String> which returns the individual lines from the reader.This is an example program demonstrating how to use the RExecClient class.
RExecClient implements the rexec() facility that first appeared in 4.2BSD Unix.
This is an example program demonstrating how to use the RLoginClient class.
RLoginClient is very similar to
RCommandClient, from which it is derived, and uses the rcmd() facility implemented in
RCommandClient to implement the functionality of the rlogin command that first appeared in 4.2BSD Unix.This is an example program demonstrating how to use the RCommandClient class.
This is an example program demonstrating how to use the FTPClient class.
This class is used to construct the bare minimum acceptable header for most newsreaders.
The SimpleNTPServer class is a UDP implementation of a server for the Network Time Protocol (NTP) version 3 as described in RFC 1305.
Simple option handler that can be used for options that don't require subnegotiation.
This class is used to construct a bare minimum acceptable header for an email message.
SMTP provides the basic the functionality necessary to implement your own SMTP client.
SMTPClient encapsulates all the functionality necessary to send files through an SMTP server.
SMTPCommand stores a set of constants for SMTP command codes.
SMTPConnectionClosedException is used to indicate the premature or unexpected closing of an SMTP connection resulting from a
SMTPReply.SERVICE_NOT_AVAILABLE response (SMTP reply code 421) to a failed SMTP command.This is an example program using the SMTP package to send a message to the specified recipients.
SMTPReply stores a set of constants for SMTP reply codes.
SMTP over SSL processing.
The SocketClient provides the basic operations that are required of client objects accessing sockets.
This class wraps an input stream, storing a reference to its originating socket.
This class wraps an output stream, storing a reference to its originating socket.
General utilities for SSLContext.
General utilities for SSLSocket.
Performs subnet calculations given a network address and a subnet mask.
Example class that shows how to use the
SubnetUtils class.Implements the telnet suppress go ahead option RFC 858.
The TelnetClient class implements the simple network virtual terminal (NVT) for the Telnet protocol according to RFC 854.
This is a simple example of use of TelnetClient.
The TelnetCommand class cannot be instantiated and only serves as a storehouse for telnet command constants.
Listener interface used for notification that incoming data is available to be read.
The TelnetNotificationHandler interface can be used to handle notification of options negotiation commands received on a telnet session.
The TelnetOption class cannot be instantiated and only serves as a storehouse for telnet option constants.
The TelnetOptionHandler class is the base class to be used for implementing handlers for telnet options.
Wraps an output stream.
Implements the telnet terminal type option RFC 1091.
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.
A final class derived from TFTPPacket defining the TFTP Acknowledgement packet type.
The TFTPClient class encapsulates all the aspects of the TFTP protocol necessary to receive and send files through TFTP.
A final class derived from TFTPPacket defining the TFTP Data packet type.
A final class derived from TFTPPacket defining the TFTP Error packet type.
This is an example of a simple Java TFTP client.
TFTPPacket is an abstract class encapsulating the functionality common to the 5 types of TFTP packets.
A class used to signify the occurrence of an error in the creation of a TFTP packet.
A class derived from TFTPRequestPacket defining a TFTP read request packet type.
An abstract class derived from TFTPPacket definiing a TFTP Request packet type.
A class derived from TFTPRequestPacket defining a TFTP write request packet type.
A placeholder interface for threadable message objects Author: Rory Winston (rwinston@checkfree.com)
This is an implementation of a message threading algorithm, as originally devised by Zamie Zawinski.
This is an example program demonstrating how to use the TimeTCPClient and TimeUDPClient classes.
Wrapper class to network time packet messages (NTP, etc.) that computes related timing info and stats.
TimeStamp class represents the Network Time Protocol (NTP) timestamp as defined in RFC-1305 and SNTP (RFC-2030).
The TimeTCPClient class is a TCP implementation of a client for the Time protocol described in RFC 868.
The TimeUDPClient class is a UDP implementation of a client for the Time protocol described in RFC 868.
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.
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.
TrustManager utilities for generating TrustManagers.
Implementation FTPFileEntryParser and FTPFileListParser for standard UNIX Systems.
The Util class cannot be instantiated and stores short static convenience methods that are often quite useful.
Utilities for mail examples
Implementation FTPFileEntryParser and FTPFileListParser for VMS Systems.
Special implementation VMSFTPEntryParser with versioning turned on.
This is an example of a trivial use of the TelnetClient class.
The WhoisClient class implements the client side of the Internet Whois Protocol defined in RFC 954.
Implements the telnet window size option RFC 1073.
ArticleInfoinstead