From 063284837c8c366e5502b1b0264b8eb807b61732 Mon Sep 17 00:00:00 2001 From: Joe Robinson Date: Wed, 27 Oct 2010 14:21:09 +0100 Subject: Basic upload functionality to predifined location, with basic file browser --- org/apache/commons/net/bsd/RCommandClient.java | 402 +++++++++++++++++++++++++ org/apache/commons/net/bsd/RExecClient.java | 292 ++++++++++++++++++ org/apache/commons/net/bsd/RLoginClient.java | 131 ++++++++ 3 files changed, 825 insertions(+) create mode 100644 org/apache/commons/net/bsd/RCommandClient.java create mode 100644 org/apache/commons/net/bsd/RExecClient.java create mode 100644 org/apache/commons/net/bsd/RLoginClient.java (limited to 'org/apache/commons/net/bsd') diff --git a/org/apache/commons/net/bsd/RCommandClient.java b/org/apache/commons/net/bsd/RCommandClient.java new file mode 100644 index 0000000..50cb87a --- /dev/null +++ b/org/apache/commons/net/bsd/RCommandClient.java @@ -0,0 +1,402 @@ +/* + * 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.bsd; + +import java.io.IOException; +import java.io.InputStream; +import java.net.BindException; +import java.net.InetAddress; +import java.net.ServerSocket; +import java.net.Socket; +import java.net.SocketException; + +import org.apache.commons.net.io.SocketInputStream; + +/*** + * RCommandClient is very similar to + * {@link org.apache.commons.net.bsd.RExecClient}, + * from which it is derived, and implements the rcmd() facility that + * first appeared in 4.2BSD Unix. rcmd() is the facility used by the rsh + * (rshell) and other commands to execute a command on another machine + * from a trusted host without issuing a password. The trust relationship + * between two machines is established by the contents of a machine's + * /etc/hosts.equiv file and a user's .rhosts file. These files specify + * from which hosts and accounts on those hosts rcmd() requests will be + * accepted. The only additional measure for establishing trust is that + * all client connections must originate from a port between 512 and 1023. + * Consequently, there is an upper limit to the number of rcmd connections + * that can be running simultaneously. The required ports are reserved + * ports on Unix systems, and can only be bound by a + * process running with root permissions (to accomplish this rsh, rlogin, + * and related commands usualy have the suid bit set). Therefore, on a + * Unix system, you will only be able to successfully use the RCommandClient + * class if the process runs as root. However, there is no such restriction + * on Windows95 and some other systems. The security risks are obvious. + * However, when carefully used, rcmd() can be very useful when used behind + * a firewall. + *

+ * As with virtually all of the client classes in org.apache.commons.net, this + * class derives from SocketClient. But it overrides most of its connection + * methods so that the local Socket will originate from an acceptable + * rshell port. The way to use RCommandClient is to first connect + * to the server, call the {@link #rcommand rcommand() } method, + * and then + * fetch the connection's input, output, and optionally error streams. + * Interaction with the remote command is controlled entirely through the + * I/O streams. Once you have finished processing the streams, you should + * invoke {@link org.apache.commons.net.bsd.RExecClient#disconnect disconnect() } + * to clean up properly. + *

+ * By default the standard output and standard error streams of the + * remote process are transmitted over the same connection, readable + * from the input stream returned by + * {@link org.apache.commons.net.bsd.RExecClient#getInputStream getInputStream() } + * . However, it is + * possible to tell the rshd daemon to return the standard error + * stream over a separate connection, readable from the input stream + * returned by {@link org.apache.commons.net.bsd.RExecClient#getErrorStream getErrorStream() } + * . You + * can specify that a separate connection should be created for standard + * error by setting the boolean separateErrorStream + * parameter of {@link #rcommand rcommand() } to true . + * The standard input of the remote process can be written to through + * the output stream returned by + * {@link org.apache.commons.net.bsd.RExecClient#getOutputStream getOutputStream() } + * . + *

+ *

+ * @author Daniel F. Savarese + * @see org.apache.commons.net.SocketClient + * @see RExecClient + * @see RLoginClient + ***/ + +public class RCommandClient extends RExecClient +{ + /*** + * The default rshell port. Set to 514 in BSD Unix. + ***/ + public static final int DEFAULT_PORT = 514; + + /*** + * The smallest port number an rcmd client may use. By BSD convention + * this number is 512. + ***/ + public static final int MIN_CLIENT_PORT = 512; + + /*** + * The largest port number an rcmd client may use. By BSD convention + * this number is 1023. + ***/ + public static final int MAX_CLIENT_PORT = 1023; + + // Overrides method in RExecClient in order to implement proper + // port number limitations. + @Override + InputStream _createErrorStream() throws IOException + { + int localPort; + ServerSocket server; + Socket socket; + + localPort = MAX_CLIENT_PORT; + server = null; // Keep compiler from barfing + + for (localPort = MAX_CLIENT_PORT; localPort >= MIN_CLIENT_PORT; --localPort) + { + try + { + server = _serverSocketFactory_.createServerSocket(localPort, 1, + getLocalAddress()); + } + catch (SocketException e) + { + continue; + } + break; + } + + if (localPort < MIN_CLIENT_PORT) + throw new BindException("All ports in use."); + + _output_.write(Integer.toString(server.getLocalPort()).getBytes()); + _output_.write('\0'); + _output_.flush(); + + socket = server.accept(); + server.close(); + + if (isRemoteVerificationEnabled() && !verifyRemote(socket)) + { + socket.close(); + throw new IOException( + "Security violation: unexpected connection attempt by " + + socket.getInetAddress().getHostAddress()); + } + + return (new SocketInputStream(socket, socket.getInputStream())); + } + + /*** + * The default RCommandClient constructor. Initializes the + * default port to DEFAULT_PORT . + ***/ + public RCommandClient() + { + setDefaultPort(DEFAULT_PORT); + } + + + /*** + * Opens a Socket connected to a remote host at the specified port and + * originating from the specified local address using a port in a range + * acceptable to the BSD rshell daemon. + * Before returning, {@link org.apache.commons.net.SocketClient#_connectAction_ _connectAction_() } + * is called to perform connection initialization actions. + *

+ * @param host The remote host. + * @param port The port to connect to on the remote host. + * @param localAddr The local address to use. + * @exception SocketException If the socket timeout could not be set. + * @exception BindException If all acceptable rshell ports are in use. + * @exception IOException If the socket could not be opened. In most + * cases you will only want to catch IOException since SocketException is + * derived from it. + ***/ + public void connect(InetAddress host, int port, InetAddress localAddr) + throws SocketException, BindException, IOException + { + int localPort; + + localPort = MAX_CLIENT_PORT; + + for (localPort = MAX_CLIENT_PORT; localPort >= MIN_CLIENT_PORT; --localPort) + { + try + { + _socket_ = + _socketFactory_.createSocket(host, port, localAddr, localPort); + } + catch (BindException be) { + continue; + } + catch (SocketException e) + { + continue; + } + break; + } + + if (localPort < MIN_CLIENT_PORT) + throw new BindException("All ports in use or insufficient permssion."); + + _connectAction_(); + } + + + + /*** + * Opens a Socket connected to a remote host at the specified port and + * originating from the current host at a port in a range acceptable + * to the BSD rshell daemon. + * Before returning, {@link org.apache.commons.net.SocketClient#_connectAction_ _connectAction_() } + * is called to perform connection initialization actions. + *

+ * @param host The remote host. + * @param port The port to connect to on the remote host. + * @exception SocketException If the socket timeout could not be set. + * @exception BindException If all acceptable rshell ports are in use. + * @exception IOException If the socket could not be opened. In most + * cases you will only want to catch IOException since SocketException is + * derived from it. + ***/ + @Override + public void connect(InetAddress host, int port) + throws SocketException, IOException + { + connect(host, port, InetAddress.getLocalHost()); + } + + + /*** + * Opens a Socket connected to a remote host at the specified port and + * originating from the current host at a port in a range acceptable + * to the BSD rshell daemon. + * Before returning, {@link org.apache.commons.net.SocketClient#_connectAction_ _connectAction_() } + * is called to perform connection initialization actions. + *

+ * @param hostname The name of the remote host. + * @param port The port to connect to on the remote host. + * @exception SocketException If the socket timeout could not be set. + * @exception BindException If all acceptable rshell ports are in use. + * @exception IOException If the socket could not be opened. In most + * cases you will only want to catch IOException since SocketException is + * derived from it. + * @exception UnknownHostException If the hostname cannot be resolved. + ***/ + @Override + public void connect(String hostname, int port) + throws SocketException, IOException + { + connect(InetAddress.getByName(hostname), port, InetAddress.getLocalHost()); + } + + + /*** + * Opens a Socket connected to a remote host at the specified port and + * originating from the specified local address using a port in a range + * acceptable to the BSD rshell daemon. + * Before returning, {@link org.apache.commons.net.SocketClient#_connectAction_ _connectAction_() } + * is called to perform connection initialization actions. + *

+ * @param hostname The remote host. + * @param port The port to connect to on the remote host. + * @param localAddr The local address to use. + * @exception SocketException If the socket timeout could not be set. + * @exception BindException If all acceptable rshell ports are in use. + * @exception IOException If the socket could not be opened. In most + * cases you will only want to catch IOException since SocketException is + * derived from it. + ***/ + public void connect(String hostname, int port, InetAddress localAddr) + throws SocketException, IOException + { + connect(InetAddress.getByName(hostname), port, localAddr); + } + + + /*** + * Opens a Socket connected to a remote host at the specified port and + * originating from the specified local address and port. The + * local port must lie between MIN_CLIENT_PORT and + * MAX_CLIENT_PORT or an IllegalArgumentException will + * be thrown. + * Before returning, {@link org.apache.commons.net.SocketClient#_connectAction_ _connectAction_() } + * is called to perform connection initialization actions. + *

+ * @param host The remote host. + * @param port The port to connect to on the remote host. + * @param localAddr The local address to use. + * @param localPort The local port to use. + * @exception SocketException If the socket timeout could not be set. + * @exception IOException If the socket could not be opened. In most + * cases you will only want to catch IOException since SocketException is + * derived from it. + * @exception IllegalArgumentException If an invalid local port number + * is specified. + ***/ + @Override + public void connect(InetAddress host, int port, + InetAddress localAddr, int localPort) + throws SocketException, IOException, IllegalArgumentException + { + if (localPort < MIN_CLIENT_PORT || localPort > MAX_CLIENT_PORT) + throw new IllegalArgumentException("Invalid port number " + localPort); + super.connect(host, port, localAddr, localPort); + } + + + /*** + * Opens a Socket connected to a remote host at the specified port and + * originating from the specified local address and port. The + * local port must lie between MIN_CLIENT_PORT and + * MAX_CLIENT_PORT or an IllegalArgumentException will + * be thrown. + * Before returning, {@link org.apache.commons.net.SocketClient#_connectAction_ _connectAction_() } + * is called to perform connection initialization actions. + *

+ * @param hostname The name of the remote host. + * @param port The port to connect to on the remote host. + * @param localAddr The local address to use. + * @param localPort The local port to use. + * @exception SocketException If the socket timeout could not be set. + * @exception IOException If the socket could not be opened. In most + * cases you will only want to catch IOException since SocketException is + * derived from it. + * @exception UnknownHostException If the hostname cannot be resolved. + * @exception IllegalArgumentException If an invalid local port number + * is specified. + ***/ + @Override + public void connect(String hostname, int port, + InetAddress localAddr, int localPort) + throws SocketException, IOException, IllegalArgumentException + { + if (localPort < MIN_CLIENT_PORT || localPort > MAX_CLIENT_PORT) + throw new IllegalArgumentException("Invalid port number " + localPort); + super.connect(hostname, port, localAddr, localPort); + } + + + /*** + * Remotely executes a command through the rshd daemon on the server + * to which the RCommandClient is connected. After calling this method, + * you may interact with the remote process through its standard input, + * output, and error streams. You will typically be able to detect + * the termination of the remote process after reaching end of file + * on its standard output (accessible through + * {@link #getInputStream getInputStream() }. Disconnecting + * from the server or closing the process streams before reaching + * end of file will not necessarily terminate the remote process. + *

+ * If a separate error stream is requested, the remote server will + * connect to a local socket opened by RCommandClient, providing an + * independent stream through which standard error will be transmitted. + * The local socket must originate from a secure port (512 - 1023), + * and rcommand() ensures that this will be so. + * RCommandClient will also do a simple security check when it accepts a + * connection for this error stream. If the connection does not originate + * from the remote server, an IOException will be thrown. This serves as + * a simple protection against possible hijacking of the error stream by + * an attacker monitoring the rexec() negotiation. You may disable this + * behavior with + * {@link org.apache.commons.net.bsd.RExecClient#setRemoteVerificationEnabled setRemoteVerificationEnabled()} + * . + *

+ * @param localUsername The user account on the local machine that is + * requesting the command execution. + * @param remoteUsername The account name on the server through which to + * execute the command. + * @param command The command, including any arguments, to execute. + * @param separateErrorStream True if you would like the standard error + * to be transmitted through a different stream than standard output. + * False if not. + * @exception IOException If the rcommand() attempt fails. The exception + * will contain a message indicating the nature of the failure. + ***/ + public void rcommand(String localUsername, String remoteUsername, + String command, boolean separateErrorStream) + throws IOException + { + rexec(localUsername, remoteUsername, command, separateErrorStream); + } + + + /*** + * Same as + * rcommand(localUsername, remoteUsername, command, false); + ***/ + public void rcommand(String localUsername, String remoteUsername, + String command) + throws IOException + { + rcommand(localUsername, remoteUsername, command, false); + } + +} + diff --git a/org/apache/commons/net/bsd/RExecClient.java b/org/apache/commons/net/bsd/RExecClient.java new file mode 100644 index 0000000..2924120 --- /dev/null +++ b/org/apache/commons/net/bsd/RExecClient.java @@ -0,0 +1,292 @@ +/* + * 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.bsd; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.ServerSocket; +import java.net.Socket; + +import org.apache.commons.net.SocketClient; +import org.apache.commons.net.io.SocketInputStream; + +/*** + * RExecClient implements the rexec() facility that first appeared in + * 4.2BSD Unix. This class will probably only be of use for connecting + * to Unix systems and only when the rexecd daemon is configured to run, + * which is a rarity these days because of the security risks involved. + * However, rexec() can be very useful for performing administrative tasks + * on a network behind a firewall. + *

+ * As with virtually all of the client classes in org.apache.commons.net, this + * class derives from SocketClient, inheriting its connection methods. + * The way to use RExecClient is to first connect + * to the server, call the {@link #rexec rexec() } method, and then + * fetch the connection's input, output, and optionally error streams. + * Interaction with the remote command is controlled entirely through the + * I/O streams. Once you have finished processing the streams, you should + * invoke {@link #disconnect disconnect() } to clean up properly. + *

+ * By default the standard output and standard error streams of the + * remote process are transmitted over the same connection, readable + * from the input stream returned by + * {@link #getInputStream getInputStream() }. However, it is + * possible to tell the rexecd daemon to return the standard error + * stream over a separate connection, readable from the input stream + * returned by {@link #getErrorStream getErrorStream() }. You + * can specify that a separate connection should be created for standard + * error by setting the boolean separateErrorStream + * parameter of {@link #rexec rexec() } to true . + * The standard input of the remote process can be written to through + * the output stream returned by + * {@link #getOutputStream getOutputSream() }. + *

+ *

+ * @author Daniel F. Savarese + * @see SocketClient + * @see RCommandClient + * @see RLoginClient + ***/ + +public class RExecClient extends SocketClient +{ + /*** + * The default rexec port. Set to 512 in BSD Unix. + ***/ + public static final int DEFAULT_PORT = 512; + + private boolean __remoteVerificationEnabled; + + /*** + * If a separate error stream is requested, _errorStream_ + * will point to an InputStream from which the standard error of the + * remote process can be read (after a call to rexec()). Otherwise, + * _errorStream_ will be null. + ***/ + protected InputStream _errorStream_; + + // This can be overridden in local package to implement port range + // limitations of rcmd and rlogin + InputStream _createErrorStream() throws IOException + { + ServerSocket server; + Socket socket; + + server = _serverSocketFactory_.createServerSocket(0, 1, getLocalAddress()); + + _output_.write(Integer.toString(server.getLocalPort()).getBytes()); + _output_.write('\0'); + _output_.flush(); + + socket = server.accept(); + server.close(); + + if (__remoteVerificationEnabled && !verifyRemote(socket)) + { + socket.close(); + throw new IOException( + "Security violation: unexpected connection attempt by " + + socket.getInetAddress().getHostAddress()); + } + + return (new SocketInputStream(socket, socket.getInputStream())); + } + + + /*** + * The default RExecClient constructor. Initializes the + * default port to DEFAULT_PORT . + ***/ + public RExecClient() + { + _errorStream_ = null; + setDefaultPort(DEFAULT_PORT); + } + + + /*** + * Returns the InputStream from which the standard outputof the remote + * process can be read. The input stream will only be set after a + * successful rexec() invocation. + *

+ * @return The InputStream from which the standard output of the remote + * process can be read. + ***/ + public InputStream getInputStream() + { + return _input_; + } + + + /*** + * Returns the OutputStream through which the standard input of the remote + * process can be written. The output stream will only be set after a + * successful rexec() invocation. + *

+ * @return The OutputStream through which the standard input of the remote + * process can be written. + ***/ + public OutputStream getOutputStream() + { + return _output_; + } + + + /*** + * Returns the InputStream from which the standard error of the remote + * process can be read if a separate error stream is requested from + * the server. Otherwise, null will be returned. The error stream + * will only be set after a successful rexec() invocation. + *

+ * @return The InputStream from which the standard error of the remote + * process can be read if a separate error stream is requested from + * the server. Otherwise, null will be returned. + ***/ + public InputStream getErrorStream() + { + return _errorStream_; + } + + + /*** + * Remotely executes a command through the rexecd daemon on the server + * to which the RExecClient is connected. After calling this method, + * you may interact with the remote process through its standard input, + * output, and error streams. You will typically be able to detect + * the termination of the remote process after reaching end of file + * on its standard output (accessible through + * {@link #getInputStream getInputStream() }. Disconnecting + * from the server or closing the process streams before reaching + * end of file will not necessarily terminate the remote process. + *

+ * If a separate error stream is requested, the remote server will + * connect to a local socket opened by RExecClient, providing an + * independent stream through which standard error will be transmitted. + * RExecClient will do a simple security check when it accepts a + * connection for this error stream. If the connection does not originate + * from the remote server, an IOException will be thrown. This serves as + * a simple protection against possible hijacking of the error stream by + * an attacker monitoring the rexec() negotiation. You may disable this + * behavior with {@link #setRemoteVerificationEnabled setRemoteVerificationEnabled()} + * . + *

+ * @param username The account name on the server through which to execute + * the command. + * @param password The plain text password of the user account. + * @param command The command, including any arguments, to execute. + * @param separateErrorStream True if you would like the standard error + * to be transmitted through a different stream than standard output. + * False if not. + * @exception IOException If the rexec() attempt fails. The exception + * will contain a message indicating the nature of the failure. + ***/ + public void rexec(String username, String password, + String command, boolean separateErrorStream) + throws IOException + { + int ch; + + if (separateErrorStream) + { + _errorStream_ = _createErrorStream(); + } + else + { + _output_.write('\0'); + } + + _output_.write(username.getBytes()); + _output_.write('\0'); + _output_.write(password.getBytes()); + _output_.write('\0'); + _output_.write(command.getBytes()); + _output_.write('\0'); + _output_.flush(); + + ch = _input_.read(); + if (ch > 0) + { + StringBuffer buffer = new StringBuffer(); + + while ((ch = _input_.read()) != -1 && ch != '\n') + buffer.append((char)ch); + + throw new IOException(buffer.toString()); + } + else if (ch < 0) + { + throw new IOException("Server closed connection."); + } + } + + + /*** + * Same as rexec(username, password, command, false); + ***/ + public void rexec(String username, String password, + String command) + throws IOException + { + rexec(username, password, command, false); + } + + /*** + * Disconnects from the server, closing all associated open sockets and + * streams. + *

+ * @exception IOException If there an error occurs while disconnecting. + ***/ + @Override + public void disconnect() throws IOException + { + if (_errorStream_ != null) + _errorStream_.close(); + _errorStream_ = null; + super.disconnect(); + } + + + /*** + * Enable or disable verification that the remote host connecting to + * create a separate error stream is the same as the host to which + * the standard out stream is connected. The default is for verification + * to be enabled. You may set this value at any time, whether the + * client is currently connected or not. + *

+ * @param enable True to enable verification, false to disable verification. + ***/ + public final void setRemoteVerificationEnabled(boolean enable) + { + __remoteVerificationEnabled = enable; + } + + /*** + * Return whether or not verification of the remote host providing a + * separate error stream is enabled. The default behavior is for + * verification to be enabled. + *

+ * @return True if verification is enabled, false if not. + ***/ + public final boolean isRemoteVerificationEnabled() + { + return __remoteVerificationEnabled; + } + +} + diff --git a/org/apache/commons/net/bsd/RLoginClient.java b/org/apache/commons/net/bsd/RLoginClient.java new file mode 100644 index 0000000..3d7c63c --- /dev/null +++ b/org/apache/commons/net/bsd/RLoginClient.java @@ -0,0 +1,131 @@ +/* + * 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.bsd; + +import java.io.IOException; + +/*** + * RLoginClient is very similar to + * {@link org.apache.commons.net.bsd.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. rlogin is a command used to login to + * a remote machine from a trusted host, sometimes without issuing a + * password. The trust relationship is the same as described in + * the documentation for + * {@link org.apache.commons.net.bsd.RCommandClient}. + *

+ * As with virtually all of the client classes in org.apache.commons.net, this + * class derives from SocketClient. But it relies on the connection + * methods defined in RcommandClient which ensure that the local Socket + * will originate from an acceptable rshell port. The way to use + * RLoginClient is to first connect + * to the server, call the {@link #rlogin rlogin() } method, + * and then + * fetch the connection's input and output streams. + * Interaction with the remote command is controlled entirely through the + * I/O streams. Once you have finished processing the streams, you should + * invoke {@link org.apache.commons.net.bsd.RExecClient#disconnect disconnect() } + * to clean up properly. + *

+ * The standard output and standard error streams of the + * remote process are transmitted over the same connection, readable + * from the input stream returned by + * {@link org.apache.commons.net.bsd.RExecClient#getInputStream getInputStream() } + * . Unlike RExecClient and RCommandClient, it is + * not possible to tell the rlogind daemon to return the standard error + * stream over a separate connection. + * {@link org.apache.commons.net.bsd.RExecClient#getErrorStream getErrorStream() } + * will always return null. + * The standard input of the remote process can be written to through + * the output stream returned by + * {@link org.apache.commons.net.bsd.RExecClient#getOutputStream getOutputSream() } + * . + *

+ *

+ * @author Daniel F. Savarese + * @see org.apache.commons.net.SocketClient + * @see RExecClient + * @see RCommandClient + ***/ + +public class RLoginClient extends RCommandClient +{ + /*** + * The default rlogin port. Set to 513 in BSD Unix and according + * to RFC 1282. + ***/ + public static final int DEFAULT_PORT = 513; + + /*** + * The default RLoginClient constructor. Initializes the + * default port to DEFAULT_PORT . + ***/ + public RLoginClient() + { + setDefaultPort(DEFAULT_PORT); + } + + + /*** + * Logins into a remote machine through the rlogind daemon on the server + * to which the RLoginClient is connected. After calling this method, + * you may interact with the remote login shell through its standard input + * and output streams. Standard error is sent over the same stream as + * standard output. You will typically be able to detect + * the termination of the remote login shell after reaching end of file + * on its standard output (accessible through + * {@link #getInputStream getInputStream() }. Disconnecting + * from the server or closing the process streams before reaching + * end of file will terminate the remote login shell in most cases. + *

+ * If user authentication fails, the rlogind daemon will request that + * a password be entered interactively. You will be able to read the + * prompt from the output stream of the RLoginClient and write the + * password to the input stream of the RLoginClient. + *

+ * @param localUsername The user account on the local machine that is + * trying to login to the remote host. + * @param remoteUsername The account name on the server that is + * being logged in to. + * @param terminalType The name of the user's terminal (e.g., "vt100", + * "network", etc.) + * @param terminalSpeed The speed of the user's terminal, expressed + * as a baud rate or bps (e.g., 9600 or 38400) + * @exception IOException If the rlogin() attempt fails. The exception + * will contain a message indicating the nature of the failure. + ***/ + public void rlogin(String localUsername, String remoteUsername, + String terminalType, int terminalSpeed) + throws IOException + { + rexec(localUsername, remoteUsername, terminalType + "/" + terminalSpeed, + false); + } + + /*** + * Same as the other rlogin method, but no terminal speed is defined. + ***/ + public void rlogin(String localUsername, String remoteUsername, + String terminalType) + throws IOException + { + rexec(localUsername, remoteUsername, terminalType, false); + } + +} -- cgit v1.2.3