<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--NewPage-->
<HTML>
<HEAD>
<!-- Generated by javadoc (build 1.5.0_12) on Tue Apr 01 14:48:50 CEST 2008 -->
<TITLE>
Index
</TITLE>


<LINK REL ="stylesheet" TYPE="text/css" HREF="./stylesheet.css" TITLE="Style">

<SCRIPT type="text/javascript">
function windowTitle()
{
    parent.document.title="Index";
}
</SCRIPT>
<NOSCRIPT>
</NOSCRIPT>

</HEAD>

<BODY BGCOLOR="white" onload="windowTitle();">


<!-- ========= START OF TOP NAVBAR ======= -->
<A NAME="navbar_top"><!-- --></A>
<A HREF="#skip-navbar_top" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_top_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./com/trilead/ssh2/package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Use</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./com/trilead/ssh2/package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
Trilead SSH-2 for Java</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_top"></A>
<!-- ========= END OF TOP NAVBAR ========= -->

<A HREF="#_A_">A</A> <A HREF="#_C_">C</A> <A HREF="#_D_">D</A> <A HREF="#_E_">E</A> <A HREF="#_F_">F</A> <A HREF="#_G_">G</A> <A HREF="#_H_">H</A> <A HREF="#_I_">I</A> <A HREF="#_K_">K</A> <A HREF="#_L_">L</A> <A HREF="#_M_">M</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_R_">R</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_U_">U</A> <A HREF="#_V_">V</A> <A HREF="#_W_">W</A> <HR>
<A NAME="_A_"><!-- --></A><H2>
<B>A</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/Connection.html#addConnectionMonitor(com.trilead.ssh2.ConnectionMonitor)"><B>addConnectionMonitor(ConnectionMonitor)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Add a <A HREF="./com/trilead/ssh2/ConnectionMonitor.html" title="interface in com.trilead.ssh2"><CODE>ConnectionMonitor</CODE></A> to this connection.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#addHostkey(java.lang.String[], java.lang.String, byte[])"><B>addHostkey(String[], String, byte[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Adds a single public key entry to the database.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#addHostkeys(char[])"><B>addHostkeys(char[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Parses the given known_hosts data and adds entries to the database.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#addHostkeys(java.io.File)"><B>addHostkeys(File)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Parses the given known_hosts file and adds entries to the database.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#addHostkeyToFile(java.io.File, java.lang.String[], java.lang.String, byte[])"><B>addHostkeyToFile(File, String[], String, byte[])</B></A> - 
Static method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Adds a single public key entry to the a known_hosts file.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#atime"><B>atime</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>The ATIME attribute.
<DT><A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html#attributes"><B>attributes</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html" title="class in com.trilead.ssh2">SFTPv3DirectoryEntry</A>
<DD>The attributes of this entry.
<DT><A HREF="./com/trilead/ssh2/Connection.html#authenticateWithDSA(java.lang.String, java.lang.String, java.lang.String)"><B>authenticateWithDSA(String, String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD><B>Deprecated.</B>&nbsp;<I>You should use one of the
             <A HREF="./com/trilead/ssh2/Connection.html#authenticateWithPublicKey(java.lang.String, java.io.File, java.lang.String)"><CODE>authenticateWithPublicKey()</CODE></A>
             methods, this method is just a wrapper for it and will
             disappear in future builds.</I>
<DT><A HREF="./com/trilead/ssh2/Connection.html#authenticateWithKeyboardInteractive(java.lang.String, com.trilead.ssh2.InteractiveCallback)"><B>authenticateWithKeyboardInteractive(String, InteractiveCallback)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>A wrapper that calls
 <A HREF="./com/trilead/ssh2/Connection.html#authenticateWithKeyboardInteractive(java.lang.String, java.lang.String[], com.trilead.ssh2.InteractiveCallback)"><CODE>authenticateWithKeyboardInteractivewith</CODE></A> a <code>null</code> submethod
 list.
<DT><A HREF="./com/trilead/ssh2/Connection.html#authenticateWithKeyboardInteractive(java.lang.String, java.lang.String[], com.trilead.ssh2.InteractiveCallback)"><B>authenticateWithKeyboardInteractive(String, String[], InteractiveCallback)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>After a successful connect, one has to authenticate oneself.
<DT><A HREF="./com/trilead/ssh2/Connection.html#authenticateWithNone(java.lang.String)"><B>authenticateWithNone(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>After a successful connect, one has to authenticate oneself.
<DT><A HREF="./com/trilead/ssh2/Connection.html#authenticateWithPassword(java.lang.String, java.lang.String)"><B>authenticateWithPassword(String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>After a successful connect, one has to authenticate oneself.
<DT><A HREF="./com/trilead/ssh2/Connection.html#authenticateWithPublicKey(java.lang.String, char[], java.lang.String)"><B>authenticateWithPublicKey(String, char[], String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>After a successful connect, one has to authenticate oneself.
<DT><A HREF="./com/trilead/ssh2/Connection.html#authenticateWithPublicKey(java.lang.String, java.io.File, java.lang.String)"><B>authenticateWithPublicKey(String, File, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>A convenience wrapper function which reads in a private key (PEM format,
 either DSA or RSA) and then calls
 <code>authenticateWithPublicKey(String, char[], String)</code>.
<DT><A HREF="./com/trilead/ssh2/StreamGobbler.html#available()"><B>available()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/StreamGobbler.html" title="class in com.trilead.ssh2">StreamGobbler</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_C_"><!-- --></A><H2>
<B>C</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/Connection.html#cancelRemotePortForwarding(int)"><B>cancelRemotePortForwarding(int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Cancel an earlier requested remote port forwarding.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#canonicalPath(java.lang.String)"><B>canonicalPath(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Have the server canonicalize any given path name to an absolute path.
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2"><B>ChannelCondition</B></A> - Interface in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>Contains constants that can be used to specify what conditions to wait for on
 a SSH-2 channel (e.g., represented by a <A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2"><CODE>Session</CODE></A>).<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#clientToServerCryptoAlgorithm"><B>clientToServerCryptoAlgorithm</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>The currently used crypto algorithm for packets from to the client to the
 server.
<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#clientToServerMACAlgorithm"><B>clientToServerMACAlgorithm</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>The currently used MAC algorithm for packets from to the client to the
 server.
<DT><A HREF="./com/trilead/ssh2/Connection.html#close()"><B>close()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Close the connection to the SSH-2 server.
<DT><A HREF="./com/trilead/ssh2/LocalPortForwarder.html#close()"><B>close()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/LocalPortForwarder.html" title="class in com.trilead.ssh2">LocalPortForwarder</A>
<DD>Stop TCP/IP forwarding of newly arriving connections.
<DT><A HREF="./com/trilead/ssh2/LocalStreamForwarder.html#close()"><B>close()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/LocalStreamForwarder.html" title="class in com.trilead.ssh2">LocalStreamForwarder</A>
<DD>Close the underlying SSH forwarding channel and free up resources.
<DT><A HREF="./com/trilead/ssh2/Session.html#close()"><B>close()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Close this session.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#close()"><B>close()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Close this SFTP session.
<DT><A HREF="./com/trilead/ssh2/StreamGobbler.html#close()"><B>close()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/StreamGobbler.html" title="class in com.trilead.ssh2">StreamGobbler</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html#CLOSED"><B>CLOSED</B></A> - 
Static variable in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2">ChannelCondition</A>
<DD>The underlying SSH-2 channel, however not necessarily the whole connection,
 has been closed.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#closeFile(com.trilead.ssh2.SFTPv3FileHandle)"><B>closeFile(SFTPv3FileHandle)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Close a file.
<DT><A HREF="./com/trilead/ssh2/package-summary.html"><B>com.trilead.ssh2</B></A> - package com.trilead.ssh2<DD>&nbsp;<DT><A HREF="./com/trilead/ssh2/Connection.html#connect()"><B>connect()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Same as
 <A HREF="./com/trilead/ssh2/Connection.html#connect(com.trilead.ssh2.ServerHostKeyVerifier, int, int)"><CODE>connect(null, 0, 0)</CODE></A>.
<DT><A HREF="./com/trilead/ssh2/Connection.html#connect(com.trilead.ssh2.ServerHostKeyVerifier)"><B>connect(ServerHostKeyVerifier)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Same as
 <A HREF="./com/trilead/ssh2/Connection.html#connect(com.trilead.ssh2.ServerHostKeyVerifier, int, int)"><CODE>connect(verifier, 0, 0)</CODE></A>.
<DT><A HREF="./com/trilead/ssh2/Connection.html#connect(com.trilead.ssh2.ServerHostKeyVerifier, int, int)"><B>connect(ServerHostKeyVerifier, int, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Connect to the SSH-2 server and, as soon as the server has presented its
 host key, use the
 <A HREF="./com/trilead/ssh2/ServerHostKeyVerifier.html#verifyServerHostKey(java.lang.String, int, java.lang.String, byte[])"><CODE>ServerHostKeyVerifier.verifyServerHostKey()</CODE></A> method of the
 <code>verifier</code> to ask for permission to proceed.
<DT><A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2"><B>Connection</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>Connection</code> is used to establish an encrypted TCP/IP
 connection to a SSH-2 server.<DT><A HREF="./com/trilead/ssh2/Connection.html#Connection(java.lang.String)"><B>Connection(String)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Prepares a fresh <code>Connection</code> object which can then be used
 to establish a connection to the specified SSH-2 server.
<DT><A HREF="./com/trilead/ssh2/Connection.html#Connection(java.lang.String, int)"><B>Connection(String, int)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Prepares a fresh <code>Connection</code> object which can then be used
 to establish a connection to the specified SSH-2 server.
<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2"><B>ConnectionInfo</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>In most cases you probably do not need the information contained in here.<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#ConnectionInfo()"><B>ConnectionInfo()</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/ConnectionMonitor.html#connectionLost(java.lang.Throwable)"><B>connectionLost(Throwable)</B></A> - 
Method in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionMonitor.html" title="interface in com.trilead.ssh2">ConnectionMonitor</A>
<DD>This method is called after the connection's underlying
 socket has been closed.
<DT><A HREF="./com/trilead/ssh2/ConnectionMonitor.html" title="interface in com.trilead.ssh2"><B>ConnectionMonitor</B></A> - Interface in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>ConnectionMonitor</code> is used to get notified when the
 underlying socket of a connection is closed.<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#createBubblebabbleFingerprint(java.lang.String, byte[])"><B>createBubblebabbleFingerprint(String, byte[])</B></A> - 
Static method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Convert a ssh2 key-blob into a human readable bubblebabble fingerprint.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#createFile(java.lang.String)"><B>createFile(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Create a file and open it for reading and writing.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#createFile(java.lang.String, com.trilead.ssh2.SFTPv3FileAttributes)"><B>createFile(String, SFTPv3FileAttributes)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Create a file and open it for reading and writing.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#createFileTruncate(java.lang.String)"><B>createFileTruncate(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Create a file (truncate it if it already exists) and open it for reading and writing.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#createFileTruncate(java.lang.String, com.trilead.ssh2.SFTPv3FileAttributes)"><B>createFileTruncate(String, SFTPv3FileAttributes)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>reate a file (truncate it if it already exists) and open it for reading and writing.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#createHashedHostname(java.lang.String)"><B>createHashedHostname(String)</B></A> - 
Static method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Generate the hashed representation of the given hostname.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#createHexFingerprint(java.lang.String, byte[])"><B>createHexFingerprint(String, byte[])</B></A> - 
Static method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Convert a ssh2 key-blob into a human readable hex fingerprint.
<DT><A HREF="./com/trilead/ssh2/Connection.html#createLocalPortForwarder(int, java.lang.String, int)"><B>createLocalPortForwarder(int, String, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Creates a new <A HREF="./com/trilead/ssh2/LocalPortForwarder.html" title="class in com.trilead.ssh2"><CODE>LocalPortForwarder</CODE></A>.
<DT><A HREF="./com/trilead/ssh2/Connection.html#createLocalPortForwarder(java.net.InetSocketAddress, java.lang.String, int)"><B>createLocalPortForwarder(InetSocketAddress, String, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Creates a new <A HREF="./com/trilead/ssh2/LocalPortForwarder.html" title="class in com.trilead.ssh2"><CODE>LocalPortForwarder</CODE></A>.
<DT><A HREF="./com/trilead/ssh2/Connection.html#createLocalStreamForwarder(java.lang.String, int)"><B>createLocalStreamForwarder(String, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Creates a new <A HREF="./com/trilead/ssh2/LocalStreamForwarder.html" title="class in com.trilead.ssh2"><CODE>LocalStreamForwarder</CODE></A>.
<DT><A HREF="./com/trilead/ssh2/Connection.html#createSCPClient()"><B>createSCPClient()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Create a very basic <A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2"><CODE>SCPClient</CODE></A> that can be used to copy files
 from/to the SSH-2 server.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#createSymlink(java.lang.String, java.lang.String)"><B>createSymlink(String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Create a symbolic link on the server.
</DL>
<HR>
<A NAME="_D_"><!-- --></A><H2>
<B>D</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/DebugLogger.html" title="interface in com.trilead.ssh2"><B>DebugLogger</B></A> - Interface in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>An interface which needs to be implemented if you
 want to capture debugging messages.<DT><A HREF="./com/trilead/ssh2/DHGexParameters.html" title="class in com.trilead.ssh2"><B>DHGexParameters</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>DHGexParameters</code> object can be used to specify parameters for
 the diffie-hellman group exchange.<DT><A HREF="./com/trilead/ssh2/DHGexParameters.html#DHGexParameters()"><B>DHGexParameters()</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/DHGexParameters.html" title="class in com.trilead.ssh2">DHGexParameters</A>
<DD>Same as calling <A HREF="./com/trilead/ssh2/DHGexParameters.html#DHGexParameters(int, int, int)"><CODE>DHGexParameters(1024, 1024, 4096)</CODE></A>.
<DT><A HREF="./com/trilead/ssh2/DHGexParameters.html#DHGexParameters(int)"><B>DHGexParameters(int)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/DHGexParameters.html" title="class in com.trilead.ssh2">DHGexParameters</A>
<DD>This constructor can be used to force the sending of a
 <code>SSH_MSG_KEX_DH_GEX_REQUEST_OLD</code> request.
<DT><A HREF="./com/trilead/ssh2/DHGexParameters.html#DHGexParameters(int, int, int)"><B>DHGexParameters(int, int, int)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/DHGexParameters.html" title="class in com.trilead.ssh2">DHGexParameters</A>
<DD>This constructor can be used to force the sending of a
 <code>SSH_MSG_KEX_DH_GEX_REQUEST</code> request.
</DL>
<HR>
<A NAME="_E_"><!-- --></A><H2>
<B>E</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/Connection.html#enableDebugging(boolean, com.trilead.ssh2.DebugLogger)"><B>enableDebugging(boolean, DebugLogger)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Enable/disable debug logging.
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html#EOF"><B>EOF</B></A> - 
Static variable in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2">ChannelCondition</A>
<DD>EOF on has been reached, no more _new_ stdout or stderr data will arrive
 from the remote server.
<DT><A HREF="./com/trilead/ssh2/Session.html#execCommand(java.lang.String)"><B>execCommand(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Execute a command on the remote machine.
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html#EXIT_SIGNAL"><B>EXIT_SIGNAL</B></A> - 
Static variable in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2">ChannelCondition</A>
<DD>The exit signal of the remote process is available.
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html#EXIT_STATUS"><B>EXIT_STATUS</B></A> - 
Static variable in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2">ChannelCondition</A>
<DD>The exit status of the remote process is available.
</DL>
<HR>
<A NAME="_F_"><!-- --></A><H2>
<B>F</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html#filename"><B>filename</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html" title="class in com.trilead.ssh2">SFTPv3DirectoryEntry</A>
<DD>A relative name within the directory, without any path components.
<DT><A HREF="./com/trilead/ssh2/Connection.html#forceKeyExchange()"><B>forceKeyExchange()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Force an asynchronous key re-exchange (the call does not block).
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#fsetstat(com.trilead.ssh2.SFTPv3FileHandle, com.trilead.ssh2.SFTPv3FileAttributes)"><B>fsetstat(SFTPv3FileHandle, SFTPv3FileAttributes)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Modify the attributes of a file.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#fstat(com.trilead.ssh2.SFTPv3FileHandle)"><B>fstat(SFTPv3FileHandle)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Retrieve the file attributes of an open file.
</DL>
<HR>
<A NAME="_G_"><!-- --></A><H2>
<B>G</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#get(java.lang.String, java.lang.String)"><B>get(String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Download a file from the remote server to a local directory.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#get(java.lang.String, java.io.OutputStream)"><B>get(String, OutputStream)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Download a file from the remote server and pipe its contents into an
 <code>OutputStream</code>.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#get(java.lang.String[], java.lang.String)"><B>get(String[], String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Download a set of files from the remote server to a local directory.
<DT><A HREF="./com/trilead/ssh2/Connection.html#getAvailableCiphers()"><B>getAvailableCiphers()</B></A> - 
Static method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Unless you know what you are doing, you will never need this.
<DT><A HREF="./com/trilead/ssh2/Connection.html#getAvailableMACs()"><B>getAvailableMACs()</B></A> - 
Static method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Unless you know what you are doing, you will never need this.
<DT><A HREF="./com/trilead/ssh2/Connection.html#getAvailableServerHostKeyAlgorithms()"><B>getAvailableServerHostKeyAlgorithms()</B></A> - 
Static method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Unless you know what you are doing, you will never need this.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#getCharset()"><B>getCharset()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>The currently used charset for filename encoding/decoding.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileHandle.html#getClient()"><B>getClient()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileHandle.html" title="class in com.trilead.ssh2">SFTPv3FileHandle</A>
<DD>Get the SFTPv3Client instance which created this handle.
<DT><A HREF="./com/trilead/ssh2/Connection.html#getConnectionInfo()"><B>getConnectionInfo()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Returns a <A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2"><CODE>ConnectionInfo</CODE></A> object containing the details of the
 connection.
<DT><A HREF="./com/trilead/ssh2/Session.html#getExitSignal()"><B>getExitSignal()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Get the name of the signal by which the process on the remote side was
 stopped - if available and applicable.
<DT><A HREF="./com/trilead/ssh2/Session.html#getExitStatus()"><B>getExitStatus()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Get the exit code/status from the remote command - if available.
<DT><A HREF="./com/trilead/ssh2/Connection.html#getHostname()"><B>getHostname()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Returns the hostname that was passed to the constructor.
<DT><A HREF="./com/trilead/ssh2/LocalStreamForwarder.html#getInputStream()"><B>getInputStream()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/LocalStreamForwarder.html" title="class in com.trilead.ssh2">LocalStreamForwarder</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/DHGexParameters.html#getMax_group_len()"><B>getMax_group_len()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/DHGexParameters.html" title="class in com.trilead.ssh2">DHGexParameters</A>
<DD>Get the maximum group length.
<DT><A HREF="./com/trilead/ssh2/DHGexParameters.html#getMin_group_len()"><B>getMin_group_len()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/DHGexParameters.html" title="class in com.trilead.ssh2">DHGexParameters</A>
<DD>Get the minimum group length.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#getOctalPermissions()"><B>getOctalPermissions()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>Turn the POSIX permissions into a 7 digit octal representation.
<DT><A HREF="./com/trilead/ssh2/LocalStreamForwarder.html#getOutputStream()"><B>getOutputStream()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/LocalStreamForwarder.html" title="class in com.trilead.ssh2">LocalStreamForwarder</A>
<DD>Get the OutputStream.
<DT><A HREF="./com/trilead/ssh2/Connection.html#getPort()"><B>getPort()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Returns the port that was passed to the constructor.
<DT><A HREF="./com/trilead/ssh2/DHGexParameters.html#getPref_group_len()"><B>getPref_group_len()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/DHGexParameters.html" title="class in com.trilead.ssh2">DHGexParameters</A>
<DD>Get the preferred group length.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#getPreferredServerHostkeyAlgorithmOrder(java.lang.String)"><B>getPreferredServerHostkeyAlgorithmOrder(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Try to find the preferred order of hostkey algorithms for the given hostname.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#getProtocolVersion()"><B>getProtocolVersion()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Returns the negotiated SFTP protocol version between the client and the server.
<DT><A HREF="./com/trilead/ssh2/Connection.html#getRemainingAuthMethods(java.lang.String)"><B>getRemainingAuthMethods(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>After a successful connect, one has to authenticate oneself.
<DT><A HREF="./com/trilead/ssh2/SFTPException.html#getServerErrorCode()"><B>getServerErrorCode()</B></A> - 
Method in exception com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPException.html" title="class in com.trilead.ssh2">SFTPException</A>
<DD>Get the error code sent by the server.
<DT><A HREF="./com/trilead/ssh2/SFTPException.html#getServerErrorCodeSymbol()"><B>getServerErrorCodeSymbol()</B></A> - 
Method in exception com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPException.html" title="class in com.trilead.ssh2">SFTPException</A>
<DD>Get the symbolic name of the error code as given in the SFTP specs.
<DT><A HREF="./com/trilead/ssh2/SFTPException.html#getServerErrorCodeVerbose()"><B>getServerErrorCodeVerbose()</B></A> - 
Method in exception com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPException.html" title="class in com.trilead.ssh2">SFTPException</A>
<DD>Get the description of the error code as given in the SFTP specs.
<DT><A HREF="./com/trilead/ssh2/SFTPException.html#getServerErrorMessage()"><B>getServerErrorMessage()</B></A> - 
Method in exception com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPException.html" title="class in com.trilead.ssh2">SFTPException</A>
<DD>Get the error message sent by the server.
<DT><A HREF="./com/trilead/ssh2/Session.html#getStderr()"><B>getStderr()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/Session.html#getStdin()"><B>getStdin()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/Session.html#getStdout()"><B>getStdout()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#gid"><B>gid</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>The GID attribute.
</DL>
<HR>
<A NAME="_H_"><!-- --></A><H2>
<B>H</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#HOSTKEY_HAS_CHANGED"><B>HOSTKEY_HAS_CHANGED</B></A> - 
Static variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#HOSTKEY_IS_NEW"><B>HOSTKEY_IS_NEW</B></A> - 
Static variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#HOSTKEY_IS_OK"><B>HOSTKEY_IS_OK</B></A> - 
Static variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/HTTPProxyException.html#httpErrorCode"><B>httpErrorCode</B></A> - 
Variable in exception com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyException.html" title="class in com.trilead.ssh2">HTTPProxyException</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2"><B>HTTPProxyData</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>HTTPProxyData</code> object is used to specify the needed connection data
 to connect through a HTTP proxy.<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#HTTPProxyData(java.lang.String, int)"><B>HTTPProxyData(String, int)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>Same as calling <A HREF="./com/trilead/ssh2/HTTPProxyData.html#HTTPProxyData(java.lang.String, int, java.lang.String, java.lang.String)"><CODE>HTTPProxyData(proxyHost, proxyPort, <code>null</code>, <code>null</code>)</CODE></A>
<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#HTTPProxyData(java.lang.String, int, java.lang.String, java.lang.String)"><B>HTTPProxyData(String, int, String, String)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>Same as calling <A HREF="./com/trilead/ssh2/HTTPProxyData.html#HTTPProxyData(java.lang.String, int, java.lang.String, java.lang.String, java.lang.String[])"><CODE>HTTPProxyData(proxyHost, proxyPort, <code>null</code>, <code>null</code>, <code>null</code>)</CODE></A>
<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#HTTPProxyData(java.lang.String, int, java.lang.String, java.lang.String, java.lang.String[])"><B>HTTPProxyData(String, int, String, String, String[])</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>Connection data for a HTTP proxy.
<DT><A HREF="./com/trilead/ssh2/HTTPProxyException.html" title="class in com.trilead.ssh2"><B>HTTPProxyException</B></A> - Exception in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>May be thrown upon connect() if a HTTP proxy is being used.<DT><A HREF="./com/trilead/ssh2/HTTPProxyException.html#HTTPProxyException(java.lang.String, int)"><B>HTTPProxyException(String, int)</B></A> - 
Constructor for exception com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyException.html" title="class in com.trilead.ssh2">HTTPProxyException</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/HTTPProxyException.html#httpResponse"><B>httpResponse</B></A> - 
Variable in exception com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyException.html" title="class in com.trilead.ssh2">HTTPProxyException</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_I_"><!-- --></A><H2>
<B>I</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/Connection.html#identification"><B>identification</B></A> - 
Static variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>The identifier presented to the SSH-2 server.
<DT><A HREF="./com/trilead/ssh2/InteractiveCallback.html" title="interface in com.trilead.ssh2"><B>InteractiveCallback</B></A> - Interface in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>An <code>InteractiveCallback</code> is used to respond to challenges sent
 by the server if authentication mode "keyboard-interactive" is selected.<DT><A HREF="./com/trilead/ssh2/Connection.html#isAuthenticationComplete()"><B>isAuthenticationComplete()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Determines if the authentication phase is complete.
<DT><A HREF="./com/trilead/ssh2/Connection.html#isAuthenticationPartialSuccess()"><B>isAuthenticationPartialSuccess()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Returns true if there was at least one failed authentication request and
 the last failed authentication request was marked with "partial success"
 by the server.
<DT><A HREF="./com/trilead/ssh2/Connection.html#isAuthMethodAvailable(java.lang.String, java.lang.String)"><B>isAuthMethodAvailable(String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Checks if a specified authentication method is available.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileHandle.html#isClosed()"><B>isClosed()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileHandle.html" title="class in com.trilead.ssh2">SFTPv3FileHandle</A>
<DD>Check if this handle was closed with the <A HREF="./com/trilead/ssh2/SFTPv3Client.html#closeFile(com.trilead.ssh2.SFTPv3FileHandle)"><CODE>SFTPv3Client.closeFile(SFTPv3FileHandle)</CODE></A> method
 of the <code>SFTPv3Client</code> instance which created the handle.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#isDirectory()"><B>isDirectory()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>Checks if this entry is a directory.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#isRegularFile()"><B>isRegularFile()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>Checks if this entry is a regular file.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#isSymlink()"><B>isSymlink()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>Checks if this entry is a a symlink.
</DL>
<HR>
<A NAME="_K_"><!-- --></A><H2>
<B>K</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#keyExchangeAlgorithm"><B>keyExchangeAlgorithm</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>The used key exchange (KEX) algorithm in the latest key exchange.
<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#keyExchangeCounter"><B>keyExchangeCounter</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>Number of kex exchanges performed on this connection so far.
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2"><B>KnownHosts</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>The <code>KnownHosts</code> class is a handy tool to verify received server hostkeys
 based on the information in <code>known_hosts</code> files (the ones used by OpenSSH).<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#KnownHosts()"><B>KnownHosts()</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#KnownHosts(char[])"><B>KnownHosts(char[])</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#KnownHosts(java.io.File)"><B>KnownHosts(File)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_L_"><!-- --></A><H2>
<B>L</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/LocalPortForwarder.html" title="class in com.trilead.ssh2"><B>LocalPortForwarder</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>LocalPortForwarder</code> forwards TCP/IP connections to a local
 port via the secure tunnel to another host (which may or may not be identical
 to the remote SSH-2 server).<DT><A HREF="./com/trilead/ssh2/LocalStreamForwarder.html" title="class in com.trilead.ssh2"><B>LocalStreamForwarder</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>LocalStreamForwarder</code> forwards an Input- and Outputstream
 pair via the secure tunnel to another host (which may or may not be identical
 to the remote SSH-2 server).<DT><A HREF="./com/trilead/ssh2/DebugLogger.html#log(int, java.lang.String, java.lang.String)"><B>log(int, String, String)</B></A> - 
Method in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/DebugLogger.html" title="interface in com.trilead.ssh2">DebugLogger</A>
<DD>Log a debug message.
<DT><A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html#longEntry"><B>longEntry</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html" title="class in com.trilead.ssh2">SFTPv3DirectoryEntry</A>
<DD>An expanded format for the file name, similar to what is returned by
 "ls -l" on Un*x systems.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#ls(java.lang.String)"><B>ls(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>List the contents of a directory.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#lstat(java.lang.String)"><B>lstat(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Retrieve the file attributes of a file.
</DL>
<HR>
<A NAME="_M_"><!-- --></A><H2>
<B>M</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#mkdir(java.lang.String, int)"><B>mkdir(String, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Create a new directory.
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#mtime"><B>mtime</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>The MTIME attribute.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#mv(java.lang.String, java.lang.String)"><B>mv(String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Move a file or directory.
</DL>
<HR>
<A NAME="_O_"><!-- --></A><H2>
<B>O</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#openFileRO(java.lang.String)"><B>openFileRO(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Open a file for reading.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#openFileRW(java.lang.String)"><B>openFileRW(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Open a file for reading and writing.
<DT><A HREF="./com/trilead/ssh2/Connection.html#openSession()"><B>openSession()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Open a new <A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2"><CODE>Session</CODE></A> on this connection.
</DL>
<HR>
<A NAME="_P_"><!-- --></A><H2>
<B>P</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#permissions"><B>permissions</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>The POSIX permissions.
<DT><A HREF="./com/trilead/ssh2/Connection.html#ping()"><B>ping()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>This method can be used to perform end-to-end connection testing.
<DT><A HREF="./com/trilead/ssh2/Session.html#ping()"><B>ping()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>This method can be used to perform end-to-end session (i.e., SSH channel)
 testing.
<DT><A HREF="./com/trilead/ssh2/ProxyData.html" title="interface in com.trilead.ssh2"><B>ProxyData</B></A> - Interface in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>An abstract marker interface implemented by all proxy data implementations.<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#proxyHost"><B>proxyHost</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#proxyPass"><B>proxyPass</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#proxyPort"><B>proxyPort</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#proxyUser"><B>proxyUser</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(java.lang.String, java.lang.String)"><B>put(String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Copy a local file to a remote directory, uses mode 0600 when creating the
 file on the remote side.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(java.lang.String[], java.lang.String)"><B>put(String[], String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Copy a set of local files to a remote directory, uses mode 0600 when
 creating files on the remote side.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(java.lang.String, java.lang.String, java.lang.String)"><B>put(String, String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Copy a local file to a remote directory, uses the specified mode when
 creating the file on the remote side.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(java.lang.String, java.lang.String, java.lang.String, java.lang.String)"><B>put(String, String, String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Copy a local file to a remote directory, uses the specified mode and
 remote filename when creating the file on the remote side.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(byte[], java.lang.String, java.lang.String)"><B>put(byte[], String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Create a remote file and copy the contents of the passed byte array into
 it.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(byte[], java.lang.String, java.lang.String, java.lang.String)"><B>put(byte[], String, String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Create a remote file and copy the contents of the passed byte array into
 it.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(java.lang.String[], java.lang.String, java.lang.String)"><B>put(String[], String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>Copy a set of local files to a remote directory, uses the specified mode
 when creating the files on the remote side.
<DT><A HREF="./com/trilead/ssh2/SCPClient.html#put(java.lang.String[], java.lang.String[], java.lang.String, java.lang.String)"><B>put(String[], String[], String, String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_R_"><!-- --></A><H2>
<B>R</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#read(com.trilead.ssh2.SFTPv3FileHandle, long, byte[], int, int)"><B>read(SFTPv3FileHandle, long, byte[], int, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Read bytes from a file.
<DT><A HREF="./com/trilead/ssh2/StreamGobbler.html#read()"><B>read()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/StreamGobbler.html" title="class in com.trilead.ssh2">StreamGobbler</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/StreamGobbler.html#read(byte[])"><B>read(byte[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/StreamGobbler.html" title="class in com.trilead.ssh2">StreamGobbler</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/StreamGobbler.html#read(byte[], int, int)"><B>read(byte[], int, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/StreamGobbler.html" title="class in com.trilead.ssh2">StreamGobbler</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#readLink(java.lang.String)"><B>readLink(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Read the target of a symbolic link.
<DT><A HREF="./com/trilead/ssh2/InteractiveCallback.html#replyToChallenge(java.lang.String, java.lang.String, int, java.lang.String[], boolean[])"><B>replyToChallenge(String, String, int, String[], boolean[])</B></A> - 
Method in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/InteractiveCallback.html" title="interface in com.trilead.ssh2">InteractiveCallback</A>
<DD>This callback interface is used during a "keyboard-interactive"
 authentication.
<DT><A HREF="./com/trilead/ssh2/Session.html#requestDumbPTY()"><B>requestDumbPTY()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Basically just a wrapper for lazy people - identical to calling
 <code>requestPTY("dumb", 0, 0, 0, 0, null)</code>.
<DT><A HREF="./com/trilead/ssh2/HTTPProxyData.html#requestHeaderLines"><B>requestHeaderLines</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/HTTPProxyData.html" title="class in com.trilead.ssh2">HTTPProxyData</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/Session.html#requestPTY(java.lang.String)"><B>requestPTY(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Basically just another wrapper for lazy people - identical to calling
 <code>requestPTY(term, 0, 0, 0, 0, null)</code>.
<DT><A HREF="./com/trilead/ssh2/Session.html#requestPTY(java.lang.String, int, int, int, int, byte[])"><B>requestPTY(String, int, int, int, int, byte[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Allocate a pseudo-terminal for this session.
<DT><A HREF="./com/trilead/ssh2/Connection.html#requestRemotePortForwarding(java.lang.String, int, java.lang.String, int)"><B>requestRemotePortForwarding(String, int, String, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Request a remote port forwarding.
<DT><A HREF="./com/trilead/ssh2/Session.html#requestX11Forwarding(java.lang.String, int, byte[], boolean)"><B>requestX11Forwarding(String, int, byte[], boolean)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Request X11 forwarding for the current session.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#rm(java.lang.String)"><B>rm(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Remove a file.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#rmdir(java.lang.String)"><B>rmdir(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Remove an empty directory.
</DL>
<HR>
<A NAME="_S_"><!-- --></A><H2>
<B>S</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2"><B>SCPClient</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A very basic <code>SCPClient</code> that can be used to copy files from/to
 the SSH-2 server.<DT><A HREF="./com/trilead/ssh2/SCPClient.html#SCPClient(com.trilead.ssh2.Connection)"><B>SCPClient(Connection)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SCPClient.html" title="class in com.trilead.ssh2">SCPClient</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/Connection.html#sendIgnorePacket()"><B>sendIgnorePacket()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Send an SSH_MSG_IGNORE packet.
<DT><A HREF="./com/trilead/ssh2/Connection.html#sendIgnorePacket(byte[])"><B>sendIgnorePacket(byte[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Send an SSH_MSG_IGNORE packet with the given data attribute.
<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#serverHostKey"><B>serverHostKey</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>The server host key that was sent during the latest key exchange.
<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#serverHostKeyAlgorithm"><B>serverHostKeyAlgorithm</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>The type of the server host key (currently either "ssh-dss" or
 "ssh-rsa").
<DT><A HREF="./com/trilead/ssh2/ServerHostKeyVerifier.html" title="interface in com.trilead.ssh2"><B>ServerHostKeyVerifier</B></A> - Interface in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A callback interface used to implement a client specific method of checking
 server host keys.<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#serverToClientCryptoAlgorithm"><B>serverToClientCryptoAlgorithm</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>The currently used crypto algorithm for packets from to the server to the
 client.
<DT><A HREF="./com/trilead/ssh2/ConnectionInfo.html#serverToClientMACAlgorithm"><B>serverToClientMACAlgorithm</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ConnectionInfo.html" title="class in com.trilead.ssh2">ConnectionInfo</A>
<DD>The currently used MAC algorithm for packets from to the server to the
 client.
<DT><A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2"><B>Session</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>Session</code> is a remote execution of a program.<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#setCharset(java.lang.String)"><B>setCharset(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Set the charset used to convert between Java Unicode Strings and byte encodings
 used by the server for paths and file names.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setClient2ServerCiphers(java.lang.String[])"><B>setClient2ServerCiphers(String[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Unless you know what you are doing, you will never need this.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setClient2ServerMACs(java.lang.String[])"><B>setClient2ServerMACs(String[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Unless you know what you are doing, you will never need this.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setDHGexParameters(com.trilead.ssh2.DHGexParameters)"><B>setDHGexParameters(DHGexParameters)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Sets the parameters for the diffie-hellman group exchange.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setProxyData(com.trilead.ssh2.ProxyData)"><B>setProxyData(ProxyData)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Used to tell the library that the connection shall be established through
 a proxy server.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setSecureRandom(java.security.SecureRandom)"><B>setSecureRandom(SecureRandom)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Provide your own instance of SecureRandom.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setServer2ClientCiphers(java.lang.String[])"><B>setServer2ClientCiphers(String[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Unless you know what you are doing, you will never need this.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setServer2ClientMACs(java.lang.String[])"><B>setServer2ClientMACs(String[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Unless you know what you are doing, you will never need this.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setServerHostKeyAlgorithms(java.lang.String[])"><B>setServerHostKeyAlgorithms(String[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Define the set of allowed server host key algorithms to be used for the
 following key exchange operations.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#setstat(java.lang.String, com.trilead.ssh2.SFTPv3FileAttributes)"><B>setstat(String, SFTPv3FileAttributes)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Modify the attributes of a file.
<DT><A HREF="./com/trilead/ssh2/Connection.html#setTCPNoDelay(boolean)"><B>setTCPNoDelay(boolean)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Connection.html" title="class in com.trilead.ssh2">Connection</A>
<DD>Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm) on the
 underlying socket.
<DT><A HREF="./com/trilead/ssh2/SFTPException.html" title="class in com.trilead.ssh2"><B>SFTPException</B></A> - Exception in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>Used in combination with the SFTPv3Client.<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2"><B>SFTPv3Client</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>SFTPv3Client</code> represents a SFTP (protocol version 3)
 client connection tunnelled over a SSH-2 connection.<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#SFTPv3Client(com.trilead.ssh2.Connection, java.io.PrintStream)"><B>SFTPv3Client(Connection, PrintStream)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD><B>Deprecated.</B>&nbsp;<I>this constructor (debug version) will disappear in the future,
             use <A HREF="./com/trilead/ssh2/SFTPv3Client.html#SFTPv3Client(com.trilead.ssh2.Connection)"><CODE>SFTPv3Client.SFTPv3Client(Connection)</CODE></A> instead.</I>
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#SFTPv3Client(com.trilead.ssh2.Connection)"><B>SFTPv3Client(Connection)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Create a SFTP v3 client.
<DT><A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html" title="class in com.trilead.ssh2"><B>SFTPv3DirectoryEntry</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>SFTPv3DirectoryEntry</code> as returned by <A HREF="./com/trilead/ssh2/SFTPv3Client.html#ls(java.lang.String)"><CODE>SFTPv3Client.ls(String)</CODE></A>.<DT><A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html#SFTPv3DirectoryEntry()"><B>SFTPv3DirectoryEntry()</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3DirectoryEntry.html" title="class in com.trilead.ssh2">SFTPv3DirectoryEntry</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2"><B>SFTPv3FileAttributes</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>SFTPv3FileAttributes</code> object represents detail information
 about a file on the server.<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#SFTPv3FileAttributes()"><B>SFTPv3FileAttributes()</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>&nbsp;
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileHandle.html" title="class in com.trilead.ssh2"><B>SFTPv3FileHandle</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>SFTPv3FileHandle</code>.<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#size"><B>size</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>The SIZE attribute.
<DT><A HREF="./com/trilead/ssh2/Session.html#startShell()"><B>startShell()</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Start a shell on the remote machine.
<DT><A HREF="./com/trilead/ssh2/Session.html#startSubSystem(java.lang.String)"><B>startSubSystem(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>Start a subsystem on the remote machine.
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#stat(java.lang.String)"><B>stat(String)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Retrieve the file attributes of a file.
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html#STDERR_DATA"><B>STDERR_DATA</B></A> - 
Static variable in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2">ChannelCondition</A>
<DD>There is stderr data available that is ready to be consumed.
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html#STDOUT_DATA"><B>STDOUT_DATA</B></A> - 
Static variable in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2">ChannelCondition</A>
<DD>There is stdout data available that is ready to be consumed.
<DT><A HREF="./com/trilead/ssh2/StreamGobbler.html" title="class in com.trilead.ssh2"><B>StreamGobbler</B></A> - Class in <A HREF="./com/trilead/ssh2/package-summary.html">com.trilead.ssh2</A><DD>A <code>StreamGobbler</code> is an InputStream that uses an internal worker
 thread to constantly consume input from another InputStream.<DT><A HREF="./com/trilead/ssh2/StreamGobbler.html#StreamGobbler(java.io.InputStream)"><B>StreamGobbler(InputStream)</B></A> - 
Constructor for class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/StreamGobbler.html" title="class in com.trilead.ssh2">StreamGobbler</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_T_"><!-- --></A><H2>
<B>T</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/ChannelCondition.html#TIMEOUT"><B>TIMEOUT</B></A> - 
Static variable in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ChannelCondition.html" title="interface in com.trilead.ssh2">ChannelCondition</A>
<DD>A timeout has occurred, none of your requested conditions is fulfilled.
</DL>
<HR>
<A NAME="_U_"><!-- --></A><H2>
<B>U</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html#uid"><B>uid</B></A> - 
Variable in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3FileAttributes.html" title="class in com.trilead.ssh2">SFTPv3FileAttributes</A>
<DD>The UID attribute.
</DL>
<HR>
<A NAME="_V_"><!-- --></A><H2>
<B>V</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/KnownHosts.html#verifyHostkey(java.lang.String, java.lang.String, byte[])"><B>verifyHostkey(String, String, byte[])</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/KnownHosts.html" title="class in com.trilead.ssh2">KnownHosts</A>
<DD>Checks the internal hostkey database for the given hostkey.
<DT><A HREF="./com/trilead/ssh2/ServerHostKeyVerifier.html#verifyServerHostKey(java.lang.String, int, java.lang.String, byte[])"><B>verifyServerHostKey(String, int, String, byte[])</B></A> - 
Method in interface com.trilead.ssh2.<A HREF="./com/trilead/ssh2/ServerHostKeyVerifier.html" title="interface in com.trilead.ssh2">ServerHostKeyVerifier</A>
<DD>The actual verifier method, it will be called by the key exchange code
 on EVERY key exchange - this can happen several times during the lifetime
 of a connection.
</DL>
<HR>
<A NAME="_W_"><!-- --></A><H2>
<B>W</B></H2>
<DL>
<DT><A HREF="./com/trilead/ssh2/Session.html#waitForCondition(int, long)"><B>waitForCondition(int, long)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD>This method blocks until certain conditions hold true on the underlying SSH-2 channel.
<DT><A HREF="./com/trilead/ssh2/Session.html#waitUntilDataAvailable(long)"><B>waitUntilDataAvailable(long)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/Session.html" title="class in com.trilead.ssh2">Session</A>
<DD><B>Deprecated.</B>&nbsp;<I>This method has been replaced with a much more powerful wait-for-condition
             interface and therefore acts only as a wrapper.</I>
<DT><A HREF="./com/trilead/ssh2/SFTPv3Client.html#write(com.trilead.ssh2.SFTPv3FileHandle, long, byte[], int, int)"><B>write(SFTPv3FileHandle, long, byte[], int, int)</B></A> - 
Method in class com.trilead.ssh2.<A HREF="./com/trilead/ssh2/SFTPv3Client.html" title="class in com.trilead.ssh2">SFTPv3Client</A>
<DD>Write bytes to a file.
</DL>
<HR>
<A HREF="#_A_">A</A> <A HREF="#_C_">C</A> <A HREF="#_D_">D</A> <A HREF="#_E_">E</A> <A HREF="#_F_">F</A> <A HREF="#_G_">G</A> <A HREF="#_H_">H</A> <A HREF="#_I_">I</A> <A HREF="#_K_">K</A> <A HREF="#_L_">L</A> <A HREF="#_M_">M</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_R_">R</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_U_">U</A> <A HREF="#_V_">V</A> <A HREF="#_W_">W</A> 

<!-- ======= START OF BOTTOM NAVBAR ====== -->
<A NAME="navbar_bottom"><!-- --></A>
<A HREF="#skip-navbar_bottom" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_bottom_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./com/trilead/ssh2/package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Use</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./com/trilead/ssh2/package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
Trilead SSH-2 for Java</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_bottom"></A>
<!-- ======== END OF BOTTOM NAVBAR ======= -->

<HR>

</BODY>
</HTML>
