code stringlengths 3 1.18M | language stringclasses 1 value |
|---|---|
package com.trilead.ssh2.packets;
import java.io.IOException;
/**
* PacketUserauthBanner.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: PacketUserauthBanner.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*/
public class PacketUserauthBanner
{
byte[] payload;
String message;
String language;
public PacketUserauthBanner(String message, String language)
{
this.message = message;
this.language = language;
}
public String getBanner()
{
return message;
}
public PacketUserauthBanner(byte payload[], int off, int len) throws IOException
{
this.payload = new byte[len];
System.arraycopy(payload, off, this.payload, 0, len);
TypesReader tr = new TypesReader(payload, off, len);
int packet_type = tr.readByte();
if (packet_type != Packets.SSH_MSG_USERAUTH_BANNER)
throw new IOException("This is not a SSH_MSG_USERAUTH_BANNER! (" + packet_type + ")");
message = tr.readString("UTF-8");
language = tr.readString();
if (tr.remain() != 0)
throw new IOException("Padding in SSH_MSG_USERAUTH_REQUEST packet!");
}
public byte[] getPayload()
{
if (payload == null)
{
TypesWriter tw = new TypesWriter();
tw.writeByte(Packets.SSH_MSG_USERAUTH_BANNER);
tw.writeString(message);
tw.writeString(language);
payload = tw.getBytes();
}
return payload;
}
}
| Java |
package com.trilead.ssh2.packets;
import java.io.IOException;
/**
* PacketNewKeys.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: PacketNewKeys.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*/
public class PacketNewKeys
{
byte[] payload;
public PacketNewKeys()
{
}
public PacketNewKeys(byte payload[], int off, int len) throws IOException
{
this.payload = new byte[len];
System.arraycopy(payload, off, this.payload, 0, len);
TypesReader tr = new TypesReader(payload, off, len);
int packet_type = tr.readByte();
if (packet_type != Packets.SSH_MSG_NEWKEYS)
throw new IOException("This is not a SSH_MSG_NEWKEYS! ("
+ packet_type + ")");
if (tr.remain() != 0)
throw new IOException("Padding in SSH_MSG_NEWKEYS packet!");
}
public byte[] getPayload()
{
if (payload == null)
{
TypesWriter tw = new TypesWriter();
tw.writeByte(Packets.SSH_MSG_NEWKEYS);
payload = tw.getBytes();
}
return payload;
}
}
| Java |
package com.trilead.ssh2.packets;
/**
* PacketSessionPtyRequest.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: PacketSessionPtyRequest.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*/
public class PacketSessionPtyRequest
{
byte[] payload;
public int recipientChannelID;
public boolean wantReply;
public String term;
public int character_width;
public int character_height;
public int pixel_width;
public int pixel_height;
public byte[] terminal_modes;
public PacketSessionPtyRequest(int recipientChannelID, boolean wantReply, String term,
int character_width, int character_height, int pixel_width, int pixel_height,
byte[] terminal_modes)
{
this.recipientChannelID = recipientChannelID;
this.wantReply = wantReply;
this.term = term;
this.character_width = character_width;
this.character_height = character_height;
this.pixel_width = pixel_width;
this.pixel_height = pixel_height;
this.terminal_modes = terminal_modes;
}
public byte[] getPayload()
{
if (payload == null)
{
TypesWriter tw = new TypesWriter();
tw.writeByte(Packets.SSH_MSG_CHANNEL_REQUEST);
tw.writeUINT32(recipientChannelID);
tw.writeString("pty-req");
tw.writeBoolean(wantReply);
tw.writeString(term);
tw.writeUINT32(character_width);
tw.writeUINT32(character_height);
tw.writeUINT32(pixel_width);
tw.writeUINT32(pixel_height);
tw.writeString(terminal_modes, 0, terminal_modes.length);
payload = tw.getBytes();
}
return payload;
}
}
| Java |
package com.trilead.ssh2.packets;
import java.io.IOException;
import java.math.BigInteger;
/**
* PacketKexDHReply.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: PacketKexDHReply.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*/
public class PacketKexDHReply
{
byte[] payload;
byte[] hostKey;
BigInteger f;
byte[] signature;
public PacketKexDHReply(byte payload[], int off, int len) throws IOException
{
this.payload = new byte[len];
System.arraycopy(payload, off, this.payload, 0, len);
TypesReader tr = new TypesReader(payload, off, len);
int packet_type = tr.readByte();
if (packet_type != Packets.SSH_MSG_KEXDH_REPLY)
throw new IOException("This is not a SSH_MSG_KEXDH_REPLY! ("
+ packet_type + ")");
hostKey = tr.readByteString();
f = tr.readMPINT();
signature = tr.readByteString();
if (tr.remain() != 0) throw new IOException("PADDING IN SSH_MSG_KEXDH_REPLY!");
}
public BigInteger getF()
{
return f;
}
public byte[] getHostKey()
{
return hostKey;
}
public byte[] getSignature()
{
return signature;
}
}
| Java |
package com.trilead.ssh2;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.SecureRandom;
import com.trilead.ssh2.channel.Channel;
import com.trilead.ssh2.channel.ChannelManager;
import com.trilead.ssh2.channel.X11ServerData;
/**
* A <code>Session</code> is a remote execution of a program. "Program" means
* in this context either a shell, an application or a system command. The
* program may or may not have a tty. Only one single program can be started on
* a session. However, multiple sessions can be active simultaneously.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: Session.java,v 1.2 2008/03/03 07:01:36 cplattne Exp $
*/
public class Session
{
ChannelManager cm;
Channel cn;
boolean flag_pty_requested = false;
boolean flag_x11_requested = false;
boolean flag_execution_started = false;
boolean flag_closed = false;
String x11FakeCookie = null;
final SecureRandom rnd;
Session(ChannelManager cm, SecureRandom rnd) throws IOException
{
this.cm = cm;
this.cn = cm.openSessionChannel();
this.rnd = rnd;
}
/**
* Basically just a wrapper for lazy people - identical to calling
* <code>requestPTY("dumb", 0, 0, 0, 0, null)</code>.
*
* @throws IOException
*/
public void requestDumbPTY() throws IOException
{
requestPTY("dumb", 0, 0, 0, 0, null);
}
/**
* Basically just another wrapper for lazy people - identical to calling
* <code>requestPTY(term, 0, 0, 0, 0, null)</code>.
*
* @throws IOException
*/
public void requestPTY(String term) throws IOException
{
requestPTY(term, 0, 0, 0, 0, null);
}
/**
* Allocate a pseudo-terminal for this session.
* <p>
* This method may only be called before a program or shell is started in
* this session.
* <p>
* Different aspects can be specified:
* <p>
* <ul>
* <li>The TERM environment variable value (e.g., vt100)</li>
* <li>The terminal's dimensions.</li>
* <li>The encoded terminal modes.</li>
* </ul>
* Zero dimension parameters are ignored. The character/row dimensions
* override the pixel dimensions (when nonzero). Pixel dimensions refer to
* the drawable area of the window. The dimension parameters are only
* informational. The encoding of terminal modes (parameter
* <code>terminal_modes</code>) is described in RFC4254.
*
* @param term
* The TERM environment variable value (e.g., vt100)
* @param term_width_characters
* terminal width, characters (e.g., 80)
* @param term_height_characters
* terminal height, rows (e.g., 24)
* @param term_width_pixels
* terminal width, pixels (e.g., 640)
* @param term_height_pixels
* terminal height, pixels (e.g., 480)
* @param terminal_modes
* encoded terminal modes (may be <code>null</code>)
* @throws IOException
*/
public void requestPTY(String term, int term_width_characters, int term_height_characters, int term_width_pixels,
int term_height_pixels, byte[] terminal_modes) throws IOException
{
if (term == null)
throw new IllegalArgumentException("TERM cannot be null.");
if ((terminal_modes != null) && (terminal_modes.length > 0))
{
if (terminal_modes[terminal_modes.length - 1] != 0)
throw new IOException("Illegal terminal modes description, does not end in zero byte");
}
else
terminal_modes = new byte[] { 0 };
synchronized (this)
{
/* The following is just a nicer error, we would catch it anyway later in the channel code */
if (flag_closed)
throw new IOException("This session is closed.");
if (flag_pty_requested)
throw new IOException("A PTY was already requested.");
if (flag_execution_started)
throw new IOException(
"Cannot request PTY at this stage anymore, a remote execution has already started.");
flag_pty_requested = true;
}
cm.requestPTY(cn, term, term_width_characters, term_height_characters, term_width_pixels, term_height_pixels,
terminal_modes);
}
/**
* Inform other side of connection that our PTY has resized.
* <p>
* Zero dimension parameters are ignored. The character/row dimensions
* override the pixel dimensions (when nonzero). Pixel dimensions refer to
* the drawable area of the window. The dimension parameters are only
* informational.
*
* @param term_width_characters
* terminal width, characters (e.g., 80)
* @param term_height_characters
* terminal height, rows (e.g., 24)
* @param term_width_pixels
* terminal width, pixels (e.g., 640)
* @param term_height_pixels
* terminal height, pixels (e.g., 480)
* @throws IOException
*/
public void resizePTY(int term_width_characters, int term_height_characters, int term_width_pixels,
int term_height_pixels) throws IOException {
synchronized (this)
{
/* The following is just a nicer error, we would catch it anyway later in the channel code */
if (flag_closed)
throw new IOException("This session is closed.");
}
cm.resizePTY(cn, term_width_characters, term_height_characters, term_width_pixels, term_height_pixels);
}
/**
* Request X11 forwarding for the current session.
* <p>
* You have to supply the name and port of your X-server.
* <p>
* This method may only be called before a program or shell is started in
* this session.
*
* @param hostname the hostname of the real (target) X11 server (e.g., 127.0.0.1)
* @param port the port of the real (target) X11 server (e.g., 6010)
* @param cookie if non-null, then present this cookie to the real X11 server
* @param singleConnection if true, then the server is instructed to only forward one single
* connection, no more connections shall be forwarded after first, or after the session
* channel has been closed
* @throws IOException
*/
public void requestX11Forwarding(String hostname, int port, byte[] cookie, boolean singleConnection)
throws IOException
{
if (hostname == null)
throw new IllegalArgumentException("hostname argument may not be null");
synchronized (this)
{
/* The following is just a nicer error, we would catch it anyway later in the channel code */
if (flag_closed)
throw new IOException("This session is closed.");
if (flag_x11_requested)
throw new IOException("X11 forwarding was already requested.");
if (flag_execution_started)
throw new IOException(
"Cannot request X11 forwarding at this stage anymore, a remote execution has already started.");
flag_x11_requested = true;
}
/* X11ServerData - used to store data about the target X11 server */
X11ServerData x11data = new X11ServerData();
x11data.hostname = hostname;
x11data.port = port;
x11data.x11_magic_cookie = cookie; /* if non-null, then present this cookie to the real X11 server */
/* Generate fake cookie - this one is used between remote clients and our proxy */
byte[] fakeCookie = new byte[16];
String hexEncodedFakeCookie;
/* Make sure that this fake cookie is unique for this connection */
while (true)
{
rnd.nextBytes(fakeCookie);
/* Generate also hex representation of fake cookie */
StringBuffer tmp = new StringBuffer(32);
for (int i = 0; i < fakeCookie.length; i++)
{
String digit2 = Integer.toHexString(fakeCookie[i] & 0xff);
tmp.append((digit2.length() == 2) ? digit2 : "0" + digit2);
}
hexEncodedFakeCookie = tmp.toString();
/* Well, yes, chances are low, but we want to be on the safe side */
if (cm.checkX11Cookie(hexEncodedFakeCookie) == null)
break;
}
/* Ask for X11 forwarding */
cm.requestX11(cn, singleConnection, "MIT-MAGIC-COOKIE-1", hexEncodedFakeCookie, 0);
/* OK, that went fine, get ready to accept X11 connections... */
/* ... but only if the user has not called close() in the meantime =) */
synchronized (this)
{
if (flag_closed == false)
{
this.x11FakeCookie = hexEncodedFakeCookie;
cm.registerX11Cookie(hexEncodedFakeCookie, x11data);
}
}
/* Now it is safe to start remote X11 programs */
}
/**
* Execute a command on the remote machine.
*
* @param cmd
* The command to execute on the remote host.
* @throws IOException
*/
public void execCommand(String cmd) throws IOException
{
if (cmd == null)
throw new IllegalArgumentException("cmd argument may not be null");
synchronized (this)
{
/* The following is just a nicer error, we would catch it anyway later in the channel code */
if (flag_closed)
throw new IOException("This session is closed.");
if (flag_execution_started)
throw new IOException("A remote execution has already started.");
flag_execution_started = true;
}
cm.requestExecCommand(cn, cmd);
}
/**
* Start a shell on the remote machine.
*
* @throws IOException
*/
public void startShell() throws IOException
{
synchronized (this)
{
/* The following is just a nicer error, we would catch it anyway later in the channel code */
if (flag_closed)
throw new IOException("This session is closed.");
if (flag_execution_started)
throw new IOException("A remote execution has already started.");
flag_execution_started = true;
}
cm.requestShell(cn);
}
/**
* Start a subsystem on the remote machine.
* Unless you know what you are doing, you will never need this.
*
* @param name the name of the subsystem.
* @throws IOException
*/
public void startSubSystem(String name) throws IOException
{
if (name == null)
throw new IllegalArgumentException("name argument may not be null");
synchronized (this)
{
/* The following is just a nicer error, we would catch it anyway later in the channel code */
if (flag_closed)
throw new IOException("This session is closed.");
if (flag_execution_started)
throw new IOException("A remote execution has already started.");
flag_execution_started = true;
}
cm.requestSubSystem(cn, name);
}
/**
* This method can be used to perform end-to-end session (i.e., SSH channel)
* testing. It sends a 'ping' message to the server and waits for the 'pong'
* from the server.
* <p>
* Implementation details: this method sends a SSH_MSG_CHANNEL_REQUEST request
* ('trilead-ping') to the server and waits for the SSH_MSG_CHANNEL_FAILURE reply
* packet.
*
* @throws IOException in case of any problem or when the session is closed
*/
public void ping() throws IOException
{
synchronized (this)
{
/*
* The following is just a nicer error, we would catch it anyway
* later in the channel code
*/
if (flag_closed)
throw new IOException("This session is closed.");
}
cm.requestChannelTrileadPing(cn);
}
/**
* Request authentication agent forwarding.
* @param agent object that implements the callbacks
*
* @throws IOException in case of any problem or when the session is closed
*/
public synchronized boolean requestAuthAgentForwarding(AuthAgentCallback agent) throws IOException
{
synchronized (this)
{
/*
* The following is just a nicer error, we would catch it anyway
* later in the channel code
*/
if (flag_closed)
throw new IOException("This session is closed.");
}
return cm.requestChannelAgentForwarding(cn, agent);
}
public InputStream getStdout()
{
return cn.getStdoutStream();
}
public InputStream getStderr()
{
return cn.getStderrStream();
}
public OutputStream getStdin()
{
return cn.getStdinStream();
}
/**
* This method blocks until there is more data available on either the
* stdout or stderr InputStream of this <code>Session</code>. Very useful
* if you do not want to use two parallel threads for reading from the two
* InputStreams. One can also specify a timeout. NOTE: do NOT call this
* method if you use concurrent threads that operate on either of the two
* InputStreams of this <code>Session</code> (otherwise this method may
* block, even though more data is available).
*
* @param timeout
* The (non-negative) timeout in <code>ms</code>. <code>0</code> means no
* timeout, the call may block forever.
* @return
* <ul>
* <li><code>0</code> if no more data will arrive.</li>
* <li><code>1</code> if more data is available.</li>
* <li><code>-1</code> if a timeout occurred.</li>
* </ul>
*
* @throws IOException
* @deprecated This method has been replaced with a much more powerful wait-for-condition
* interface and therefore acts only as a wrapper.
*
*/
public int waitUntilDataAvailable(long timeout) throws IOException
{
if (timeout < 0)
throw new IllegalArgumentException("timeout must not be negative!");
int conditions = cm.waitForCondition(cn, timeout, ChannelCondition.STDOUT_DATA | ChannelCondition.STDERR_DATA
| ChannelCondition.EOF);
if ((conditions & ChannelCondition.TIMEOUT) != 0)
return -1;
if ((conditions & (ChannelCondition.STDOUT_DATA | ChannelCondition.STDERR_DATA)) != 0)
return 1;
/* Here we do not need to check separately for CLOSED, since CLOSED implies EOF */
if ((conditions & ChannelCondition.EOF) != 0)
return 0;
throw new IllegalStateException("Unexpected condition result (" + conditions + ")");
}
/**
* This method blocks until certain conditions hold true on the underlying SSH-2 channel.
* <p>
* This method returns as soon as one of the following happens:
* <ul>
* <li>at least of the specified conditions (see {@link ChannelCondition}) holds true</li>
* <li>timeout > 0 and a timeout occured (TIMEOUT will be set in result conditions)</a>
* <li>the underlying channel was closed (CLOSED will be set in result conditions)</a>
* </ul>
* <p>
* In any case, the result value contains ALL current conditions, which may be more
* than the specified condition set (i.e., never use the "==" operator to test for conditions
* in the bitmask, see also comments in {@link ChannelCondition}).
* <p>
* Note: do NOT call this method if you want to wait for STDOUT_DATA or STDERR_DATA and
* there are concurrent threads (e.g., StreamGobblers) that operate on either of the two
* InputStreams of this <code>Session</code> (otherwise this method may
* block, even though more data is available in the StreamGobblers).
*
* @param condition_set a bitmask based on {@link ChannelCondition} values
* @param timeout non-negative timeout in ms, <code>0</code> means no timeout
* @return all bitmask specifying all current conditions that are true
*/
public int waitForCondition(int condition_set, long timeout)
{
if (timeout < 0)
throw new IllegalArgumentException("timeout must be non-negative!");
return cm.waitForCondition(cn, timeout, condition_set);
}
/**
* Get the exit code/status from the remote command - if available. Be
* careful - not all server implementations return this value. It is
* generally a good idea to call this method only when all data from the
* remote side has been consumed (see also the <code<WaitForCondition</code> method).
*
* @return An <code>Integer</code> holding the exit code, or
* <code>null</code> if no exit code is (yet) available.
*/
public Integer getExitStatus()
{
return cn.getExitStatus();
}
/**
* Get the name of the signal by which the process on the remote side was
* stopped - if available and applicable. Be careful - not all server
* implementations return this value.
*
* @return An <code>String</code> holding the name of the signal, or
* <code>null</code> if the process exited normally or is still
* running (or if the server forgot to send this information).
*/
public String getExitSignal()
{
return cn.getExitSignal();
}
/**
* Close this session. NEVER forget to call this method to free up resources -
* even if you got an exception from one of the other methods (or when
* getting an Exception on the Input- or OutputStreams). Sometimes these other
* methods may throw an exception, saying that the underlying channel is
* closed (this can happen, e.g., if the other server sent a close message.)
* However, as long as you have not called the <code>close()</code>
* method, you may be wasting (local) resources.
*
*/
public void close()
{
synchronized (this)
{
if (flag_closed)
return;
flag_closed = true;
if (x11FakeCookie != null)
cm.unRegisterX11Cookie(x11FakeCookie, true);
try
{
cm.closeChannel(cn, "Closed due to user request", true);
}
catch (IOException ignored)
{
}
}
}
}
| Java |
package com.trilead.ssh2.transport;
/**
* NegotiatedParameters.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: NegotiatedParameters.java,v 1.1 2007/10/15 12:49:57 cplattne Exp $
*/
public class NegotiatedParameters
{
public boolean guessOK;
public String kex_algo;
public String server_host_key_algo;
public String enc_algo_client_to_server;
public String enc_algo_server_to_client;
public String mac_algo_client_to_server;
public String mac_algo_server_to_client;
public String comp_algo_client_to_server;
public String comp_algo_server_to_client;
public String lang_client_to_server;
public String lang_server_to_client;
}
| Java |
package com.trilead.ssh2.transport;
/**
* NegotiateException.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: NegotiateException.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class NegotiateException extends Exception
{
private static final long serialVersionUID = 3689910669428143157L;
}
| Java |
package com.trilead.ssh2.transport;
import java.io.IOException;
/**
* MessageHandler.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: MessageHandler.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public interface MessageHandler
{
public void handleMessage(byte[] msg, int msglen) throws IOException;
}
| Java |
package com.trilead.ssh2.transport;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import com.trilead.ssh2.Connection;
/**
* ClientServerHello.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: ClientServerHello.java,v 1.2 2008/04/01 12:38:09 cplattne Exp $
*/
public class ClientServerHello
{
String server_line;
String client_line;
String server_versioncomment;
public final static int readLineRN(InputStream is, byte[] buffer) throws IOException
{
int pos = 0;
boolean need10 = false;
int len = 0;
while (true)
{
int c = is.read();
if (c == -1)
throw new IOException("Premature connection close");
buffer[pos++] = (byte) c;
if (c == 13)
{
need10 = true;
continue;
}
if (c == 10)
break;
if (need10 == true)
throw new IOException("Malformed line sent by the server, the line does not end correctly.");
len++;
if (pos >= buffer.length)
throw new IOException("The server sent a too long line.");
}
return len;
}
public ClientServerHello(InputStream bi, OutputStream bo) throws IOException
{
client_line = "SSH-2.0-" + Connection.identification;
bo.write((client_line + "\r\n").getBytes("ISO-8859-1"));
bo.flush();
byte[] serverVersion = new byte[512];
for (int i = 0; i < 50; i++)
{
int len = readLineRN(bi, serverVersion);
server_line = new String(serverVersion, 0, len, "ISO-8859-1");
if (server_line.startsWith("SSH-"))
break;
}
if (server_line.startsWith("SSH-") == false)
throw new IOException(
"Malformed server identification string. There was no line starting with 'SSH-' amongst the first 50 lines.");
if (server_line.startsWith("SSH-1.99-"))
server_versioncomment = server_line.substring(9);
else if (server_line.startsWith("SSH-2.0-"))
server_versioncomment = server_line.substring(8);
else
throw new IOException("Server uses incompatible protocol, it is not SSH-2 compatible.");
}
/**
* @return Returns the client_versioncomment.
*/
public byte[] getClientString()
{
byte[] result;
try
{
result = client_line.getBytes("ISO-8859-1");
}
catch (UnsupportedEncodingException ign)
{
result = client_line.getBytes();
}
return result;
}
/**
* @return Returns the server_versioncomment.
*/
public byte[] getServerString()
{
byte[] result;
try
{
result = server_line.getBytes("ISO-8859-1");
}
catch (UnsupportedEncodingException ign)
{
result = server_line.getBytes();
}
return result;
}
}
| Java |
package com.trilead.ssh2.transport;
/**
* KexParameters.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: KexParameters.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class KexParameters
{
public byte[] cookie;
public String[] kex_algorithms;
public String[] server_host_key_algorithms;
public String[] encryption_algorithms_client_to_server;
public String[] encryption_algorithms_server_to_client;
public String[] mac_algorithms_client_to_server;
public String[] mac_algorithms_server_to_client;
public String[] compression_algorithms_client_to_server;
public String[] compression_algorithms_server_to_client;
public String[] languages_client_to_server;
public String[] languages_server_to_client;
public boolean first_kex_packet_follows;
public int reserved_field1;
}
| Java |
package com.trilead.ssh2.transport;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.SecureRandom;
import java.util.Vector;
import com.trilead.ssh2.ConnectionInfo;
import com.trilead.ssh2.ConnectionMonitor;
import com.trilead.ssh2.DHGexParameters;
import com.trilead.ssh2.HTTPProxyData;
import com.trilead.ssh2.HTTPProxyException;
import com.trilead.ssh2.ProxyData;
import com.trilead.ssh2.ServerHostKeyVerifier;
import com.trilead.ssh2.compression.ICompressor;
import com.trilead.ssh2.crypto.Base64;
import com.trilead.ssh2.crypto.CryptoWishList;
import com.trilead.ssh2.crypto.cipher.BlockCipher;
import com.trilead.ssh2.crypto.digest.MAC;
import com.trilead.ssh2.log.Logger;
import com.trilead.ssh2.packets.PacketDisconnect;
import com.trilead.ssh2.packets.Packets;
import com.trilead.ssh2.packets.TypesReader;
import com.trilead.ssh2.util.Tokenizer;
/*
* Yes, the "standard" is a big mess. On one side, the say that arbitary channel
* packets are allowed during kex exchange, on the other side we need to blindly
* ignore the next _packet_ if the KEX guess was wrong. Where do we know from that
* the next packet is not a channel data packet? Yes, we could check if it is in
* the KEX range. But the standard says nothing about this. The OpenSSH guys
* block local "normal" traffic during KEX. That's fine - however, they assume
* that the other side is doing the same. During re-key, if they receive traffic
* other than KEX, they become horribly irritated and kill the connection. Since
* we are very likely going to communicate with OpenSSH servers, we have to play
* the same game - even though we could do better.
*
* btw: having stdout and stderr on the same channel, with a shared window, is
* also a VERY good idea... =(
*/
/**
* TransportManager.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: TransportManager.java,v 1.2 2008/04/01 12:38:09 cplattne Exp $
*/
public class TransportManager
{
private static final Logger log = Logger.getLogger(TransportManager.class);
class HandlerEntry
{
MessageHandler mh;
int low;
int high;
}
private final Vector<byte[]> asynchronousQueue = new Vector<byte[]>();
private Thread asynchronousThread = null;
class AsynchronousWorker extends Thread
{
public void run()
{
while (true)
{
byte[] msg = null;
synchronized (asynchronousQueue)
{
if (asynchronousQueue.size() == 0)
{
/* After the queue is empty for about 2 seconds, stop this thread */
try
{
asynchronousQueue.wait(2000);
}
catch (InterruptedException e)
{
/* OKOK, if somebody interrupts us, then we may die earlier. */
}
if (asynchronousQueue.size() == 0)
{
asynchronousThread = null;
return;
}
}
msg = asynchronousQueue.remove(0);
}
/* The following invocation may throw an IOException.
* There is no point in handling it - it simply means
* that the connection has a problem and we should stop
* sending asynchronously messages. We do not need to signal that
* we have exited (asynchronousThread = null): further
* messages in the queue cannot be sent by this or any
* other thread.
* Other threads will sooner or later (when receiving or
* sending the next message) get the same IOException and
* get to the same conclusion.
*/
try
{
sendMessage(msg);
}
catch (IOException e)
{
return;
}
}
}
}
String hostname;
int port;
final Socket sock = new Socket();
Object connectionSemaphore = new Object();
boolean flagKexOngoing = false;
boolean connectionClosed = false;
Throwable reasonClosedCause = null;
TransportConnection tc;
KexManager km;
Vector<HandlerEntry> messageHandlers = new Vector<HandlerEntry>();
Thread receiveThread;
Vector connectionMonitors = new Vector();
boolean monitorsWereInformed = false;
/**
* There were reports that there are JDKs which use
* the resolver even though one supplies a dotted IP
* address in the Socket constructor. That is why we
* try to generate the InetAdress "by hand".
*
* @param host
* @return the InetAddress
* @throws UnknownHostException
*/
private InetAddress createInetAddress(String host) throws UnknownHostException
{
/* Check if it is a dotted IP4 address */
InetAddress addr = parseIPv4Address(host);
if (addr != null)
return addr;
return InetAddress.getByName(host);
}
private InetAddress parseIPv4Address(String host) throws UnknownHostException
{
if (host == null)
return null;
String[] quad = Tokenizer.parseTokens(host, '.');
if ((quad == null) || (quad.length != 4))
return null;
byte[] addr = new byte[4];
for (int i = 0; i < 4; i++)
{
int part = 0;
if ((quad[i].length() == 0) || (quad[i].length() > 3))
return null;
for (int k = 0; k < quad[i].length(); k++)
{
char c = quad[i].charAt(k);
/* No, Character.isDigit is not the same */
if ((c < '0') || (c > '9'))
return null;
part = part * 10 + (c - '0');
}
if (part > 255) /* 300.1.2.3 is invalid =) */
return null;
addr[i] = (byte) part;
}
return InetAddress.getByAddress(host, addr);
}
public TransportManager(String host, int port) throws IOException
{
this.hostname = host;
this.port = port;
}
public int getPacketOverheadEstimate()
{
return tc.getPacketOverheadEstimate();
}
public void setTcpNoDelay(boolean state) throws IOException
{
sock.setTcpNoDelay(state);
}
public void setSoTimeout(int timeout) throws IOException
{
sock.setSoTimeout(timeout);
}
public ConnectionInfo getConnectionInfo(int kexNumber) throws IOException
{
return km.getOrWaitForConnectionInfo(kexNumber);
}
public Throwable getReasonClosedCause()
{
synchronized (connectionSemaphore)
{
return reasonClosedCause;
}
}
public byte[] getSessionIdentifier()
{
return km.sessionId;
}
public void close(Throwable cause, boolean useDisconnectPacket)
{
if (useDisconnectPacket == false)
{
/* OK, hard shutdown - do not aquire the semaphore,
* perhaps somebody is inside (and waits until the remote
* side is ready to accept new data). */
try
{
sock.close();
}
catch (IOException ignore)
{
}
/* OK, whoever tried to send data, should now agree that
* there is no point in further waiting =)
* It is safe now to aquire the semaphore.
*/
}
synchronized (connectionSemaphore)
{
if (connectionClosed == false)
{
if (useDisconnectPacket == true)
{
try
{
byte[] msg = new PacketDisconnect(Packets.SSH_DISCONNECT_BY_APPLICATION, cause.getMessage(), "")
.getPayload();
if (tc != null)
tc.sendMessage(msg);
}
catch (IOException ignore)
{
}
try
{
sock.close();
}
catch (IOException ignore)
{
}
}
connectionClosed = true;
reasonClosedCause = cause; /* may be null */
}
connectionSemaphore.notifyAll();
}
/* No check if we need to inform the monitors */
Vector monitors = null;
synchronized (this)
{
/* Short term lock to protect "connectionMonitors"
* and "monitorsWereInformed"
* (they may be modified concurrently)
*/
if (monitorsWereInformed == false)
{
monitorsWereInformed = true;
monitors = (Vector) connectionMonitors.clone();
}
}
if (monitors != null)
{
for (int i = 0; i < monitors.size(); i++)
{
try
{
ConnectionMonitor cmon = (ConnectionMonitor) monitors.elementAt(i);
cmon.connectionLost(reasonClosedCause);
}
catch (Exception ignore)
{
}
}
}
}
private void establishConnection(ProxyData proxyData, int connectTimeout) throws IOException
{
/* See the comment for createInetAddress() */
if (proxyData == null)
{
InetAddress addr = createInetAddress(hostname);
sock.connect(new InetSocketAddress(addr, port), connectTimeout);
sock.setSoTimeout(0);
return;
}
if (proxyData instanceof HTTPProxyData)
{
HTTPProxyData pd = (HTTPProxyData) proxyData;
/* At the moment, we only support HTTP proxies */
InetAddress addr = createInetAddress(pd.proxyHost);
sock.connect(new InetSocketAddress(addr, pd.proxyPort), connectTimeout);
sock.setSoTimeout(0);
/* OK, now tell the proxy where we actually want to connect to */
StringBuffer sb = new StringBuffer();
sb.append("CONNECT ");
sb.append(hostname);
sb.append(':');
sb.append(port);
sb.append(" HTTP/1.0\r\n");
if ((pd.proxyUser != null) && (pd.proxyPass != null))
{
String credentials = pd.proxyUser + ":" + pd.proxyPass;
char[] encoded = Base64.encode(credentials.getBytes("ISO-8859-1"));
sb.append("Proxy-Authorization: Basic ");
sb.append(encoded);
sb.append("\r\n");
}
if (pd.requestHeaderLines != null)
{
for (int i = 0; i < pd.requestHeaderLines.length; i++)
{
if (pd.requestHeaderLines[i] != null)
{
sb.append(pd.requestHeaderLines[i]);
sb.append("\r\n");
}
}
}
sb.append("\r\n");
OutputStream out = sock.getOutputStream();
out.write(sb.toString().getBytes("ISO-8859-1"));
out.flush();
/* Now parse the HTTP response */
byte[] buffer = new byte[1024];
InputStream in = sock.getInputStream();
int len = ClientServerHello.readLineRN(in, buffer);
String httpReponse = new String(buffer, 0, len, "ISO-8859-1");
if (httpReponse.startsWith("HTTP/") == false)
throw new IOException("The proxy did not send back a valid HTTP response.");
/* "HTTP/1.X XYZ X" => 14 characters minimum */
if ((httpReponse.length() < 14) || (httpReponse.charAt(8) != ' ') || (httpReponse.charAt(12) != ' '))
throw new IOException("The proxy did not send back a valid HTTP response.");
int errorCode = 0;
try
{
errorCode = Integer.parseInt(httpReponse.substring(9, 12));
}
catch (NumberFormatException ignore)
{
throw new IOException("The proxy did not send back a valid HTTP response.");
}
if ((errorCode < 0) || (errorCode > 999))
throw new IOException("The proxy did not send back a valid HTTP response.");
if (errorCode != 200)
{
throw new HTTPProxyException(httpReponse.substring(13), errorCode);
}
/* OK, read until empty line */
while (true)
{
len = ClientServerHello.readLineRN(in, buffer);
if (len == 0)
break;
}
return;
}
throw new IOException("Unsupported ProxyData");
}
public void initialize(CryptoWishList cwl, ServerHostKeyVerifier verifier, DHGexParameters dhgex,
int connectTimeout, SecureRandom rnd, ProxyData proxyData) throws IOException
{
/* First, establish the TCP connection to the SSH-2 server */
establishConnection(proxyData, connectTimeout);
/* Parse the server line and say hello - important: this information is later needed for the
* key exchange (to stop man-in-the-middle attacks) - that is why we wrap it into an object
* for later use.
*/
ClientServerHello csh = new ClientServerHello(sock.getInputStream(), sock.getOutputStream());
tc = new TransportConnection(sock.getInputStream(), sock.getOutputStream(), rnd);
km = new KexManager(this, csh, cwl, hostname, port, verifier, rnd);
km.initiateKEX(cwl, dhgex);
receiveThread = new Thread(new Runnable()
{
public void run()
{
try
{
receiveLoop();
}
catch (IOException e)
{
close(e, false);
if (log.isEnabled())
log.log(10, "Receive thread: error in receiveLoop: " + e.getMessage());
}
if (log.isEnabled())
log.log(50, "Receive thread: back from receiveLoop");
/* Tell all handlers that it is time to say goodbye */
if (km != null)
{
try
{
km.handleMessage(null, 0);
}
catch (IOException e)
{
}
}
for (int i = 0; i < messageHandlers.size(); i++)
{
HandlerEntry he = messageHandlers.elementAt(i);
try
{
he.mh.handleMessage(null, 0);
}
catch (Exception ignore)
{
}
}
}
});
receiveThread.setDaemon(true);
receiveThread.start();
}
public void registerMessageHandler(MessageHandler mh, int low, int high)
{
HandlerEntry he = new HandlerEntry();
he.mh = mh;
he.low = low;
he.high = high;
synchronized (messageHandlers)
{
messageHandlers.addElement(he);
}
}
public void removeMessageHandler(MessageHandler mh, int low, int high)
{
synchronized (messageHandlers)
{
for (int i = 0; i < messageHandlers.size(); i++)
{
HandlerEntry he = messageHandlers.elementAt(i);
if ((he.mh == mh) && (he.low == low) && (he.high == high))
{
messageHandlers.removeElementAt(i);
break;
}
}
}
}
public void sendKexMessage(byte[] msg) throws IOException
{
synchronized (connectionSemaphore)
{
if (connectionClosed)
{
throw (IOException) new IOException("Sorry, this connection is closed.").initCause(reasonClosedCause);
}
flagKexOngoing = true;
try
{
tc.sendMessage(msg);
}
catch (IOException e)
{
close(e, false);
throw e;
}
}
}
public void kexFinished() throws IOException
{
synchronized (connectionSemaphore)
{
flagKexOngoing = false;
connectionSemaphore.notifyAll();
}
}
public void forceKeyExchange(CryptoWishList cwl, DHGexParameters dhgex) throws IOException
{
km.initiateKEX(cwl, dhgex);
}
public void changeRecvCipher(BlockCipher bc, MAC mac)
{
tc.changeRecvCipher(bc, mac);
}
public void changeSendCipher(BlockCipher bc, MAC mac)
{
tc.changeSendCipher(bc, mac);
}
/**
* @param comp
*/
public void changeRecvCompression(ICompressor comp) {
tc.changeRecvCompression(comp);
}
/**
* @param comp
*/
public void changeSendCompression(ICompressor comp) {
tc.changeSendCompression(comp);
}
/**
*
*/
public void startCompression() {
tc.startCompression();
}
public void sendAsynchronousMessage(byte[] msg) throws IOException
{
synchronized (asynchronousQueue)
{
asynchronousQueue.addElement(msg);
/* This limit should be flexible enough. We need this, otherwise the peer
* can flood us with global requests (and other stuff where we have to reply
* with an asynchronous message) and (if the server just sends data and does not
* read what we send) this will probably put us in a low memory situation
* (our send queue would grow and grow and...) */
if (asynchronousQueue.size() > 100)
throw new IOException("Error: the peer is not consuming our asynchronous replies.");
/* Check if we have an asynchronous sending thread */
if (asynchronousThread == null)
{
asynchronousThread = new AsynchronousWorker();
asynchronousThread.setDaemon(true);
asynchronousThread.start();
/* The thread will stop after 2 seconds of inactivity (i.e., empty queue) */
}
}
}
public void setConnectionMonitors(Vector monitors)
{
synchronized (this)
{
connectionMonitors = (Vector) monitors.clone();
}
}
public void sendMessage(byte[] msg) throws IOException
{
if (Thread.currentThread() == receiveThread)
throw new IOException("Assertion error: sendMessage may never be invoked by the receiver thread!");
synchronized (connectionSemaphore)
{
while (true)
{
if (connectionClosed)
{
throw (IOException) new IOException("Sorry, this connection is closed.")
.initCause(reasonClosedCause);
}
if (flagKexOngoing == false)
break;
try
{
connectionSemaphore.wait();
}
catch (InterruptedException e)
{
}
}
try
{
tc.sendMessage(msg);
}
catch (IOException e)
{
close(e, false);
throw e;
}
}
}
public void receiveLoop() throws IOException
{
byte[] msg = new byte[35000];
while (true)
{
int msglen = tc.receiveMessage(msg, 0, msg.length);
int type = msg[0] & 0xff;
if (type == Packets.SSH_MSG_IGNORE)
continue;
if (type == Packets.SSH_MSG_DEBUG)
{
if (log.isEnabled())
{
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte();
tr.readBoolean();
StringBuffer debugMessageBuffer = new StringBuffer();
debugMessageBuffer.append(tr.readString("UTF-8"));
for (int i = 0; i < debugMessageBuffer.length(); i++)
{
char c = debugMessageBuffer.charAt(i);
if ((c >= 32) && (c <= 126))
continue;
debugMessageBuffer.setCharAt(i, '\uFFFD');
}
log.log(50, "DEBUG Message from remote: '" + debugMessageBuffer.toString() + "'");
}
continue;
}
if (type == Packets.SSH_MSG_UNIMPLEMENTED)
{
throw new IOException("Peer sent UNIMPLEMENTED message, that should not happen.");
}
if (type == Packets.SSH_MSG_DISCONNECT)
{
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte();
int reason_code = tr.readUINT32();
StringBuffer reasonBuffer = new StringBuffer();
reasonBuffer.append(tr.readString("UTF-8"));
/*
* Do not get fooled by servers that send abnormal long error
* messages
*/
if (reasonBuffer.length() > 255)
{
reasonBuffer.setLength(255);
reasonBuffer.setCharAt(254, '.');
reasonBuffer.setCharAt(253, '.');
reasonBuffer.setCharAt(252, '.');
}
/*
* Also, check that the server did not send charcaters that may
* screw up the receiver -> restrict to reasonable US-ASCII
* subset -> "printable characters" (ASCII 32 - 126). Replace
* all others with 0xFFFD (UNICODE replacement character).
*/
for (int i = 0; i < reasonBuffer.length(); i++)
{
char c = reasonBuffer.charAt(i);
if ((c >= 32) && (c <= 126))
continue;
reasonBuffer.setCharAt(i, '\uFFFD');
}
throw new IOException("Peer sent DISCONNECT message (reason code " + reason_code + "): "
+ reasonBuffer.toString());
}
/*
* Is it a KEX Packet?
*/
if ((type == Packets.SSH_MSG_KEXINIT) || (type == Packets.SSH_MSG_NEWKEYS)
|| ((type >= 30) && (type <= 49)))
{
km.handleMessage(msg, msglen);
continue;
}
if (type == Packets.SSH_MSG_USERAUTH_SUCCESS) {
tc.startCompression();
}
MessageHandler mh = null;
for (int i = 0; i < messageHandlers.size(); i++)
{
HandlerEntry he = messageHandlers.elementAt(i);
if ((he.low <= type) && (type <= he.high))
{
mh = he.mh;
break;
}
}
if (mh == null)
throw new IOException("Unexpected SSH message (type " + type + ")");
mh.handleMessage(msg, msglen);
}
}
}
| Java |
package com.trilead.ssh2.transport;
import java.math.BigInteger;
import com.trilead.ssh2.DHGexParameters;
import com.trilead.ssh2.crypto.dh.DhExchange;
import com.trilead.ssh2.crypto.dh.DhGroupExchange;
import com.trilead.ssh2.packets.PacketKexInit;
/**
* KexState.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: KexState.java,v 1.1 2007/10/15 12:49:57 cplattne Exp $
*/
public class KexState
{
public PacketKexInit localKEX;
public PacketKexInit remoteKEX;
public NegotiatedParameters np;
public int state = 0;
public BigInteger K;
public byte[] H;
public byte[] hostkey;
public DhExchange dhx;
public DhGroupExchange dhgx;
public DHGexParameters dhgexParameters;
}
| Java |
package com.trilead.ssh2.transport;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.SecureRandom;
import com.trilead.ssh2.compression.ICompressor;
import com.trilead.ssh2.crypto.cipher.BlockCipher;
import com.trilead.ssh2.crypto.cipher.CipherInputStream;
import com.trilead.ssh2.crypto.cipher.CipherOutputStream;
import com.trilead.ssh2.crypto.cipher.NullCipher;
import com.trilead.ssh2.crypto.digest.MAC;
import com.trilead.ssh2.log.Logger;
import com.trilead.ssh2.packets.Packets;
/**
* TransportConnection.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: TransportConnection.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class TransportConnection
{
private static final Logger log = Logger.getLogger(TransportConnection.class);
int send_seq_number = 0;
int recv_seq_number = 0;
CipherInputStream cis;
CipherOutputStream cos;
boolean useRandomPadding = false;
/* Depends on current MAC and CIPHER */
MAC send_mac;
byte[] send_mac_buffer;
int send_padd_blocksize = 8;
MAC recv_mac;
byte[] recv_mac_buffer;
byte[] recv_mac_buffer_cmp;
int recv_padd_blocksize = 8;
ICompressor recv_comp = null;
ICompressor send_comp = null;
boolean can_recv_compress = false;
boolean can_send_compress = false;
byte[] recv_comp_buffer;
byte[] send_comp_buffer;
/* won't change */
final byte[] send_padding_buffer = new byte[256];
final byte[] send_packet_header_buffer = new byte[5];
final byte[] recv_padding_buffer = new byte[256];
final byte[] recv_packet_header_buffer = new byte[5];
boolean recv_packet_header_present = false;
ClientServerHello csh;
final SecureRandom rnd;
public TransportConnection(InputStream is, OutputStream os, SecureRandom rnd)
{
this.cis = new CipherInputStream(new NullCipher(), is);
this.cos = new CipherOutputStream(new NullCipher(), os);
this.rnd = rnd;
}
public void changeRecvCipher(BlockCipher bc, MAC mac)
{
cis.changeCipher(bc);
recv_mac = mac;
recv_mac_buffer = (mac != null) ? new byte[mac.size()] : null;
recv_mac_buffer_cmp = (mac != null) ? new byte[mac.size()] : null;
recv_padd_blocksize = bc.getBlockSize();
if (recv_padd_blocksize < 8)
recv_padd_blocksize = 8;
}
public void changeSendCipher(BlockCipher bc, MAC mac)
{
if ((bc instanceof NullCipher) == false)
{
/* Only use zero byte padding for the first few packets */
useRandomPadding = true;
/* Once we start encrypting, there is no way back */
}
cos.changeCipher(bc);
send_mac = mac;
send_mac_buffer = (mac != null) ? new byte[mac.size()] : null;
send_padd_blocksize = bc.getBlockSize();
if (send_padd_blocksize < 8)
send_padd_blocksize = 8;
}
public void changeRecvCompression(ICompressor comp)
{
recv_comp = comp;
if (comp != null) {
recv_comp_buffer = new byte[comp.getBufferSize()];
can_recv_compress |= recv_comp.canCompressPreauth();
}
}
public void changeSendCompression(ICompressor comp)
{
send_comp = comp;
if (comp != null) {
send_comp_buffer = new byte[comp.getBufferSize()];
can_send_compress |= send_comp.canCompressPreauth();
}
}
public void sendMessage(byte[] message) throws IOException
{
sendMessage(message, 0, message.length, 0);
}
public void sendMessage(byte[] message, int off, int len) throws IOException
{
sendMessage(message, off, len, 0);
}
public int getPacketOverheadEstimate()
{
// return an estimate for the paket overhead (for send operations)
return 5 + 4 + (send_padd_blocksize - 1) + send_mac_buffer.length;
}
public void sendMessage(byte[] message, int off, int len, int padd) throws IOException
{
if (padd < 4)
padd = 4;
else if (padd > 64)
padd = 64;
if (send_comp != null && can_send_compress) {
if (send_comp_buffer.length < message.length + 1024)
send_comp_buffer = new byte[message.length + 1024];
len = send_comp.compress(message, off, len, send_comp_buffer);
message = send_comp_buffer;
}
int packet_len = 5 + len + padd; /* Minimum allowed padding is 4 */
int slack = packet_len % send_padd_blocksize;
if (slack != 0)
{
packet_len += (send_padd_blocksize - slack);
}
if (packet_len < 16)
packet_len = 16;
int padd_len = packet_len - (5 + len);
if (useRandomPadding)
{
for (int i = 0; i < padd_len; i = i + 4)
{
/*
* don't waste calls to rnd.nextInt() (by using only 8bit of the
* output). just believe me: even though we may write here up to 3
* bytes which won't be used, there is no "buffer overflow" (i.e.,
* arrayindexoutofbounds). the padding buffer is big enough =) (256
* bytes, and that is bigger than any current cipher block size + 64).
*/
int r = rnd.nextInt();
send_padding_buffer[i] = (byte) r;
send_padding_buffer[i + 1] = (byte) (r >> 8);
send_padding_buffer[i + 2] = (byte) (r >> 16);
send_padding_buffer[i + 3] = (byte) (r >> 24);
}
}
else
{
/* use zero padding for unencrypted traffic */
for (int i = 0; i < padd_len; i++)
send_padding_buffer[i] = 0;
/* Actually this code is paranoid: we never filled any
* bytes into the padding buffer so far, therefore it should
* consist of zeros only.
*/
}
send_packet_header_buffer[0] = (byte) ((packet_len - 4) >> 24);
send_packet_header_buffer[1] = (byte) ((packet_len - 4) >> 16);
send_packet_header_buffer[2] = (byte) ((packet_len - 4) >> 8);
send_packet_header_buffer[3] = (byte) ((packet_len - 4));
send_packet_header_buffer[4] = (byte) padd_len;
cos.write(send_packet_header_buffer, 0, 5);
cos.write(message, off, len);
cos.write(send_padding_buffer, 0, padd_len);
if (send_mac != null)
{
send_mac.initMac(send_seq_number);
send_mac.update(send_packet_header_buffer, 0, 5);
send_mac.update(message, off, len);
send_mac.update(send_padding_buffer, 0, padd_len);
send_mac.getMac(send_mac_buffer, 0);
cos.writePlain(send_mac_buffer, 0, send_mac_buffer.length);
}
cos.flush();
if (log.isEnabled())
{
log.log(90, "Sent " + Packets.getMessageName(message[off] & 0xff) + " " + len + " bytes payload");
}
send_seq_number++;
}
public int peekNextMessageLength() throws IOException
{
if (recv_packet_header_present == false)
{
cis.read(recv_packet_header_buffer, 0, 5);
recv_packet_header_present = true;
}
int packet_length = ((recv_packet_header_buffer[0] & 0xff) << 24)
| ((recv_packet_header_buffer[1] & 0xff) << 16) | ((recv_packet_header_buffer[2] & 0xff) << 8)
| ((recv_packet_header_buffer[3] & 0xff));
int padding_length = recv_packet_header_buffer[4] & 0xff;
if (packet_length > 35000 || packet_length < 12)
throw new IOException("Illegal packet size! (" + packet_length + ")");
int payload_length = packet_length - padding_length - 1;
if (payload_length < 0)
throw new IOException("Illegal padding_length in packet from remote (" + padding_length + ")");
return payload_length;
}
public int receiveMessage(byte buffer[], int off, int len) throws IOException
{
if (recv_packet_header_present == false)
{
cis.read(recv_packet_header_buffer, 0, 5);
}
else
recv_packet_header_present = false;
int packet_length = ((recv_packet_header_buffer[0] & 0xff) << 24)
| ((recv_packet_header_buffer[1] & 0xff) << 16) | ((recv_packet_header_buffer[2] & 0xff) << 8)
| ((recv_packet_header_buffer[3] & 0xff));
int padding_length = recv_packet_header_buffer[4] & 0xff;
if (packet_length > 35000 || packet_length < 12)
throw new IOException("Illegal packet size! (" + packet_length + ")");
int payload_length = packet_length - padding_length - 1;
if (payload_length < 0)
throw new IOException("Illegal padding_length in packet from remote (" + padding_length + ")");
if (payload_length >= len)
throw new IOException("Receive buffer too small (" + len + ", need " + payload_length + ")");
cis.read(buffer, off, payload_length);
cis.read(recv_padding_buffer, 0, padding_length);
if (recv_mac != null)
{
cis.readPlain(recv_mac_buffer, 0, recv_mac_buffer.length);
recv_mac.initMac(recv_seq_number);
recv_mac.update(recv_packet_header_buffer, 0, 5);
recv_mac.update(buffer, off, payload_length);
recv_mac.update(recv_padding_buffer, 0, padding_length);
recv_mac.getMac(recv_mac_buffer_cmp, 0);
for (int i = 0; i < recv_mac_buffer.length; i++)
{
if (recv_mac_buffer[i] != recv_mac_buffer_cmp[i])
throw new IOException("Remote sent corrupt MAC.");
}
}
recv_seq_number++;
if (log.isEnabled())
{
log.log(90, "Received " + Packets.getMessageName(buffer[off] & 0xff) + " " + payload_length
+ " bytes payload");
}
if (recv_comp != null && can_recv_compress) {
int[] uncomp_len = new int[] { payload_length };
buffer = recv_comp.uncompress(buffer, off, uncomp_len);
if (buffer == null) {
throw new IOException("Error while inflating remote data");
} else {
return uncomp_len[0];
}
} else {
return payload_length;
}
}
/**
*
*/
public void startCompression() {
can_recv_compress = true;
can_send_compress = true;
}
}
| Java |
package com.trilead.ssh2.transport;
import java.io.IOException;
import java.security.SecureRandom;
import com.trilead.ssh2.ConnectionInfo;
import com.trilead.ssh2.DHGexParameters;
import com.trilead.ssh2.ServerHostKeyVerifier;
import com.trilead.ssh2.compression.CompressionFactory;
import com.trilead.ssh2.compression.ICompressor;
import com.trilead.ssh2.crypto.CryptoWishList;
import com.trilead.ssh2.crypto.KeyMaterial;
import com.trilead.ssh2.crypto.cipher.BlockCipher;
import com.trilead.ssh2.crypto.cipher.BlockCipherFactory;
import com.trilead.ssh2.crypto.dh.DhExchange;
import com.trilead.ssh2.crypto.dh.DhGroupExchange;
import com.trilead.ssh2.crypto.digest.MAC;
import com.trilead.ssh2.log.Logger;
import com.trilead.ssh2.packets.PacketKexDHInit;
import com.trilead.ssh2.packets.PacketKexDHReply;
import com.trilead.ssh2.packets.PacketKexDhGexGroup;
import com.trilead.ssh2.packets.PacketKexDhGexInit;
import com.trilead.ssh2.packets.PacketKexDhGexReply;
import com.trilead.ssh2.packets.PacketKexDhGexRequest;
import com.trilead.ssh2.packets.PacketKexDhGexRequestOld;
import com.trilead.ssh2.packets.PacketKexInit;
import com.trilead.ssh2.packets.PacketNewKeys;
import com.trilead.ssh2.packets.Packets;
import com.trilead.ssh2.signature.DSAPublicKey;
import com.trilead.ssh2.signature.DSASHA1Verify;
import com.trilead.ssh2.signature.DSASignature;
import com.trilead.ssh2.signature.RSAPublicKey;
import com.trilead.ssh2.signature.RSASHA1Verify;
import com.trilead.ssh2.signature.RSASignature;
/**
* KexManager.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: KexManager.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class KexManager
{
private static final Logger log = Logger.getLogger(KexManager.class);
KexState kxs;
int kexCount = 0;
KeyMaterial km;
byte[] sessionId;
ClientServerHello csh;
final Object accessLock = new Object();
ConnectionInfo lastConnInfo = null;
boolean connectionClosed = false;
boolean ignore_next_kex_packet = false;
final TransportManager tm;
CryptoWishList nextKEXcryptoWishList;
DHGexParameters nextKEXdhgexParameters;
ServerHostKeyVerifier verifier;
final String hostname;
final int port;
final SecureRandom rnd;
public KexManager(TransportManager tm, ClientServerHello csh, CryptoWishList initialCwl, String hostname, int port,
ServerHostKeyVerifier keyVerifier, SecureRandom rnd)
{
this.tm = tm;
this.csh = csh;
this.nextKEXcryptoWishList = initialCwl;
this.nextKEXdhgexParameters = new DHGexParameters();
this.hostname = hostname;
this.port = port;
this.verifier = keyVerifier;
this.rnd = rnd;
}
public ConnectionInfo getOrWaitForConnectionInfo(int minKexCount) throws IOException
{
synchronized (accessLock)
{
while (true)
{
if ((lastConnInfo != null) && (lastConnInfo.keyExchangeCounter >= minKexCount))
return lastConnInfo;
if (connectionClosed)
throw (IOException) new IOException("Key exchange was not finished, connection is closed.")
.initCause(tm.getReasonClosedCause());
try
{
accessLock.wait();
}
catch (InterruptedException e)
{
}
}
}
}
private String getFirstMatch(String[] client, String[] server) throws NegotiateException
{
if (client == null || server == null)
throw new IllegalArgumentException();
if (client.length == 0)
return null;
for (int i = 0; i < client.length; i++)
{
for (int j = 0; j < server.length; j++)
{
if (client[i].equals(server[j]))
return client[i];
}
}
throw new NegotiateException();
}
private boolean compareFirstOfNameList(String[] a, String[] b)
{
if (a == null || b == null)
throw new IllegalArgumentException();
if ((a.length == 0) && (b.length == 0))
return true;
if ((a.length == 0) || (b.length == 0))
return false;
return (a[0].equals(b[0]));
}
private boolean isGuessOK(KexParameters cpar, KexParameters spar)
{
if (cpar == null || spar == null)
throw new IllegalArgumentException();
if (compareFirstOfNameList(cpar.kex_algorithms, spar.kex_algorithms) == false)
{
return false;
}
if (compareFirstOfNameList(cpar.server_host_key_algorithms, spar.server_host_key_algorithms) == false)
{
return false;
}
/*
* We do NOT check here if the other algorithms can be agreed on, this
* is just a check if kex_algorithms and server_host_key_algorithms were
* guessed right!
*/
return true;
}
private NegotiatedParameters mergeKexParameters(KexParameters client, KexParameters server)
{
NegotiatedParameters np = new NegotiatedParameters();
try
{
np.kex_algo = getFirstMatch(client.kex_algorithms, server.kex_algorithms);
log.log(20, "kex_algo=" + np.kex_algo);
np.server_host_key_algo = getFirstMatch(client.server_host_key_algorithms,
server.server_host_key_algorithms);
log.log(20, "server_host_key_algo=" + np.server_host_key_algo);
np.enc_algo_client_to_server = getFirstMatch(client.encryption_algorithms_client_to_server,
server.encryption_algorithms_client_to_server);
np.enc_algo_server_to_client = getFirstMatch(client.encryption_algorithms_server_to_client,
server.encryption_algorithms_server_to_client);
log.log(20, "enc_algo_client_to_server=" + np.enc_algo_client_to_server);
log.log(20, "enc_algo_server_to_client=" + np.enc_algo_server_to_client);
np.mac_algo_client_to_server = getFirstMatch(client.mac_algorithms_client_to_server,
server.mac_algorithms_client_to_server);
np.mac_algo_server_to_client = getFirstMatch(client.mac_algorithms_server_to_client,
server.mac_algorithms_server_to_client);
log.log(20, "mac_algo_client_to_server=" + np.mac_algo_client_to_server);
log.log(20, "mac_algo_server_to_client=" + np.mac_algo_server_to_client);
np.comp_algo_client_to_server = getFirstMatch(client.compression_algorithms_client_to_server,
server.compression_algorithms_client_to_server);
np.comp_algo_server_to_client = getFirstMatch(client.compression_algorithms_server_to_client,
server.compression_algorithms_server_to_client);
log.log(20, "comp_algo_client_to_server=" + np.comp_algo_client_to_server);
log.log(20, "comp_algo_server_to_client=" + np.comp_algo_server_to_client);
}
catch (NegotiateException e)
{
return null;
}
try
{
np.lang_client_to_server = getFirstMatch(client.languages_client_to_server,
server.languages_client_to_server);
}
catch (NegotiateException e1)
{
np.lang_client_to_server = null;
}
try
{
np.lang_server_to_client = getFirstMatch(client.languages_server_to_client,
server.languages_server_to_client);
}
catch (NegotiateException e2)
{
np.lang_server_to_client = null;
}
if (isGuessOK(client, server))
np.guessOK = true;
return np;
}
public synchronized void initiateKEX(CryptoWishList cwl, DHGexParameters dhgex) throws IOException
{
nextKEXcryptoWishList = cwl;
nextKEXdhgexParameters = dhgex;
if (kxs == null)
{
kxs = new KexState();
kxs.dhgexParameters = nextKEXdhgexParameters;
PacketKexInit kp = new PacketKexInit(nextKEXcryptoWishList, rnd);
kxs.localKEX = kp;
tm.sendKexMessage(kp.getPayload());
}
}
private boolean establishKeyMaterial()
{
try
{
int mac_cs_key_len = MAC.getKeyLen(kxs.np.mac_algo_client_to_server);
int enc_cs_key_len = BlockCipherFactory.getKeySize(kxs.np.enc_algo_client_to_server);
int enc_cs_block_len = BlockCipherFactory.getBlockSize(kxs.np.enc_algo_client_to_server);
int mac_sc_key_len = MAC.getKeyLen(kxs.np.mac_algo_server_to_client);
int enc_sc_key_len = BlockCipherFactory.getKeySize(kxs.np.enc_algo_server_to_client);
int enc_sc_block_len = BlockCipherFactory.getBlockSize(kxs.np.enc_algo_server_to_client);
km = KeyMaterial.create("SHA1", kxs.H, kxs.K, sessionId, enc_cs_key_len, enc_cs_block_len, mac_cs_key_len,
enc_sc_key_len, enc_sc_block_len, mac_sc_key_len);
}
catch (IllegalArgumentException e)
{
return false;
}
return true;
}
private void finishKex() throws IOException
{
if (sessionId == null)
sessionId = kxs.H;
establishKeyMaterial();
/* Tell the other side that we start using the new material */
PacketNewKeys ign = new PacketNewKeys();
tm.sendKexMessage(ign.getPayload());
BlockCipher cbc;
MAC mac;
ICompressor comp;
try
{
cbc = BlockCipherFactory.createCipher(kxs.np.enc_algo_client_to_server, true, km.enc_key_client_to_server,
km.initial_iv_client_to_server);
mac = new MAC(kxs.np.mac_algo_client_to_server, km.integrity_key_client_to_server);
comp = CompressionFactory.createCompressor(kxs.np.comp_algo_client_to_server);
}
catch (IllegalArgumentException e1)
{
throw new IOException("Fatal error during MAC startup!");
}
tm.changeSendCipher(cbc, mac);
tm.changeSendCompression(comp);
tm.kexFinished();
}
public static final String[] getDefaultServerHostkeyAlgorithmList()
{
return new String[] { "ssh-rsa", "ssh-dss" };
}
public static final void checkServerHostkeyAlgorithmsList(String[] algos)
{
for (int i = 0; i < algos.length; i++)
{
if (("ssh-rsa".equals(algos[i]) == false) && ("ssh-dss".equals(algos[i]) == false))
throw new IllegalArgumentException("Unknown server host key algorithm '" + algos[i] + "'");
}
}
public static final String[] getDefaultKexAlgorithmList()
{
return new String[] { "diffie-hellman-group-exchange-sha1", "diffie-hellman-group14-sha1",
"diffie-hellman-group1-sha1" };
}
public static final void checkKexAlgorithmList(String[] algos)
{
for (int i = 0; i < algos.length; i++)
{
if ("diffie-hellman-group-exchange-sha1".equals(algos[i]))
continue;
if ("diffie-hellman-group14-sha1".equals(algos[i]))
continue;
if ("diffie-hellman-group1-sha1".equals(algos[i]))
continue;
throw new IllegalArgumentException("Unknown kex algorithm '" + algos[i] + "'");
}
}
private boolean verifySignature(byte[] sig, byte[] hostkey) throws IOException
{
if (kxs.np.server_host_key_algo.equals("ssh-rsa"))
{
RSASignature rs = RSASHA1Verify.decodeSSHRSASignature(sig);
RSAPublicKey rpk = RSASHA1Verify.decodeSSHRSAPublicKey(hostkey);
log.log(50, "Verifying ssh-rsa signature");
return RSASHA1Verify.verifySignature(kxs.H, rs, rpk);
}
if (kxs.np.server_host_key_algo.equals("ssh-dss"))
{
DSASignature ds = DSASHA1Verify.decodeSSHDSASignature(sig);
DSAPublicKey dpk = DSASHA1Verify.decodeSSHDSAPublicKey(hostkey);
log.log(50, "Verifying ssh-dss signature");
return DSASHA1Verify.verifySignature(kxs.H, ds, dpk);
}
throw new IOException("Unknown server host key algorithm '" + kxs.np.server_host_key_algo + "'");
}
public synchronized void handleMessage(byte[] msg, int msglen) throws IOException
{
PacketKexInit kip;
if (msg == null)
{
synchronized (accessLock)
{
connectionClosed = true;
accessLock.notifyAll();
return;
}
}
if ((kxs == null) && (msg[0] != Packets.SSH_MSG_KEXINIT))
throw new IOException("Unexpected KEX message (type " + msg[0] + ")");
if (ignore_next_kex_packet)
{
ignore_next_kex_packet = false;
return;
}
if (msg[0] == Packets.SSH_MSG_KEXINIT)
{
if ((kxs != null) && (kxs.state != 0))
throw new IOException("Unexpected SSH_MSG_KEXINIT message during on-going kex exchange!");
if (kxs == null)
{
/*
* Ah, OK, peer wants to do KEX. Let's be nice and play
* together.
*/
kxs = new KexState();
kxs.dhgexParameters = nextKEXdhgexParameters;
kip = new PacketKexInit(nextKEXcryptoWishList, rnd);
kxs.localKEX = kip;
tm.sendKexMessage(kip.getPayload());
}
kip = new PacketKexInit(msg, 0, msglen);
kxs.remoteKEX = kip;
kxs.np = mergeKexParameters(kxs.localKEX.getKexParameters(), kxs.remoteKEX.getKexParameters());
if (kxs.np == null)
throw new IOException("Cannot negotiate, proposals do not match.");
if (kxs.remoteKEX.isFirst_kex_packet_follows() && (kxs.np.guessOK == false))
{
/*
* Guess was wrong, we need to ignore the next kex packet.
*/
ignore_next_kex_packet = true;
}
if (kxs.np.kex_algo.equals("diffie-hellman-group-exchange-sha1"))
{
if (kxs.dhgexParameters.getMin_group_len() == 0 || csh.server_versioncomment.matches("OpenSSH_2\\.([0-4]\\.|5\\.[0-2]).*"))
{
PacketKexDhGexRequestOld dhgexreq = new PacketKexDhGexRequestOld(kxs.dhgexParameters);
tm.sendKexMessage(dhgexreq.getPayload());
}
else
{
PacketKexDhGexRequest dhgexreq = new PacketKexDhGexRequest(kxs.dhgexParameters);
tm.sendKexMessage(dhgexreq.getPayload());
}
kxs.state = 1;
return;
}
if (kxs.np.kex_algo.equals("diffie-hellman-group1-sha1")
|| kxs.np.kex_algo.equals("diffie-hellman-group14-sha1"))
{
kxs.dhx = new DhExchange();
if (kxs.np.kex_algo.equals("diffie-hellman-group1-sha1"))
kxs.dhx.init(1, rnd);
else
kxs.dhx.init(14, rnd);
PacketKexDHInit kp = new PacketKexDHInit(kxs.dhx.getE());
tm.sendKexMessage(kp.getPayload());
kxs.state = 1;
return;
}
throw new IllegalStateException("Unkown KEX method!");
}
if (msg[0] == Packets.SSH_MSG_NEWKEYS)
{
if (km == null)
throw new IOException("Peer sent SSH_MSG_NEWKEYS, but I have no key material ready!");
BlockCipher cbc;
MAC mac;
ICompressor comp;
try
{
cbc = BlockCipherFactory.createCipher(kxs.np.enc_algo_server_to_client, false,
km.enc_key_server_to_client, km.initial_iv_server_to_client);
mac = new MAC(kxs.np.mac_algo_server_to_client, km.integrity_key_server_to_client);
comp = CompressionFactory.createCompressor(kxs.np.comp_algo_server_to_client);
}
catch (IllegalArgumentException e1)
{
throw new IOException("Fatal error during MAC startup!");
}
tm.changeRecvCipher(cbc, mac);
tm.changeRecvCompression(comp);
ConnectionInfo sci = new ConnectionInfo();
kexCount++;
sci.keyExchangeAlgorithm = kxs.np.kex_algo;
sci.keyExchangeCounter = kexCount;
sci.clientToServerCryptoAlgorithm = kxs.np.enc_algo_client_to_server;
sci.serverToClientCryptoAlgorithm = kxs.np.enc_algo_server_to_client;
sci.clientToServerMACAlgorithm = kxs.np.mac_algo_client_to_server;
sci.serverToClientMACAlgorithm = kxs.np.mac_algo_server_to_client;
sci.serverHostKeyAlgorithm = kxs.np.server_host_key_algo;
sci.serverHostKey = kxs.hostkey;
synchronized (accessLock)
{
lastConnInfo = sci;
accessLock.notifyAll();
}
kxs = null;
return;
}
if ((kxs == null) || (kxs.state == 0))
throw new IOException("Unexpected Kex submessage!");
if (kxs.np.kex_algo.equals("diffie-hellman-group-exchange-sha1"))
{
if (kxs.state == 1)
{
PacketKexDhGexGroup dhgexgrp = new PacketKexDhGexGroup(msg, 0, msglen);
kxs.dhgx = new DhGroupExchange(dhgexgrp.getP(), dhgexgrp.getG());
kxs.dhgx.init(rnd);
PacketKexDhGexInit dhgexinit = new PacketKexDhGexInit(kxs.dhgx.getE());
tm.sendKexMessage(dhgexinit.getPayload());
kxs.state = 2;
return;
}
if (kxs.state == 2)
{
PacketKexDhGexReply dhgexrpl = new PacketKexDhGexReply(msg, 0, msglen);
kxs.hostkey = dhgexrpl.getHostKey();
if (verifier != null)
{
boolean vres = false;
try
{
vres = verifier.verifyServerHostKey(hostname, port, kxs.np.server_host_key_algo, kxs.hostkey);
}
catch (Exception e)
{
throw (IOException) new IOException(
"The server hostkey was not accepted by the verifier callback.").initCause(e);
}
if (vres == false)
throw new IOException("The server hostkey was not accepted by the verifier callback");
}
kxs.dhgx.setF(dhgexrpl.getF());
try
{
kxs.H = kxs.dhgx.calculateH(csh.getClientString(), csh.getServerString(),
kxs.localKEX.getPayload(), kxs.remoteKEX.getPayload(), dhgexrpl.getHostKey(),
kxs.dhgexParameters);
}
catch (IllegalArgumentException e)
{
throw (IOException) new IOException("KEX error.").initCause(e);
}
boolean res = verifySignature(dhgexrpl.getSignature(), kxs.hostkey);
if (res == false)
throw new IOException("Hostkey signature sent by remote is wrong!");
kxs.K = kxs.dhgx.getK();
finishKex();
kxs.state = -1;
return;
}
throw new IllegalStateException("Illegal State in KEX Exchange!");
}
if (kxs.np.kex_algo.equals("diffie-hellman-group1-sha1")
|| kxs.np.kex_algo.equals("diffie-hellman-group14-sha1"))
{
if (kxs.state == 1)
{
PacketKexDHReply dhr = new PacketKexDHReply(msg, 0, msglen);
kxs.hostkey = dhr.getHostKey();
if (verifier != null)
{
boolean vres = false;
try
{
vres = verifier.verifyServerHostKey(hostname, port, kxs.np.server_host_key_algo, kxs.hostkey);
}
catch (Exception e)
{
throw (IOException) new IOException(
"The server hostkey was not accepted by the verifier callback.").initCause(e);
}
if (vres == false)
throw new IOException("The server hostkey was not accepted by the verifier callback");
}
kxs.dhx.setF(dhr.getF());
try
{
kxs.H = kxs.dhx.calculateH(csh.getClientString(), csh.getServerString(), kxs.localKEX.getPayload(),
kxs.remoteKEX.getPayload(), dhr.getHostKey());
}
catch (IllegalArgumentException e)
{
throw (IOException) new IOException("KEX error.").initCause(e);
}
boolean res = verifySignature(dhr.getSignature(), kxs.hostkey);
if (res == false)
throw new IOException("Hostkey signature sent by remote is wrong!");
kxs.K = kxs.dhx.getK();
finishKex();
kxs.state = -1;
return;
}
}
throw new IllegalStateException("Unkown KEX method! (" + kxs.np.kex_algo + ")");
}
}
| Java |
package com.trilead.ssh2;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* A very basic <code>SCPClient</code> that can be used to copy files from/to
* the SSH-2 server. On the server side, the "scp" program must be in the PATH.
* <p>
* This scp client is thread safe - you can download (and upload) different sets
* of files concurrently without any troubles. The <code>SCPClient</code> is
* actually mapping every request to a distinct {@link Session}.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: SCPClient.java,v 1.2 2008/04/01 12:38:09 cplattne Exp $
*/
public class SCPClient
{
Connection conn;
class LenNamePair
{
long length;
String filename;
}
public SCPClient(Connection conn)
{
if (conn == null)
throw new IllegalArgumentException("Cannot accept null argument!");
this.conn = conn;
}
private void readResponse(InputStream is) throws IOException
{
int c = is.read();
if (c == 0)
return;
if (c == -1)
throw new IOException("Remote scp terminated unexpectedly.");
if ((c != 1) && (c != 2))
throw new IOException("Remote scp sent illegal error code.");
if (c == 2)
throw new IOException("Remote scp terminated with error.");
String err = receiveLine(is);
throw new IOException("Remote scp terminated with error (" + err + ").");
}
private String receiveLine(InputStream is) throws IOException
{
StringBuffer sb = new StringBuffer(30);
while (true)
{
/*
* This is a random limit - if your path names are longer, then
* adjust it
*/
if (sb.length() > 8192)
throw new IOException("Remote scp sent a too long line");
int c = is.read();
if (c < 0)
throw new IOException("Remote scp terminated unexpectedly.");
if (c == '\n')
break;
sb.append((char) c);
}
return sb.toString();
}
private LenNamePair parseCLine(String line) throws IOException
{
/* Minimum line: "xxxx y z" ---> 8 chars */
long len;
if (line.length() < 8)
throw new IOException("Malformed C line sent by remote SCP binary, line too short.");
if ((line.charAt(4) != ' ') || (line.charAt(5) == ' '))
throw new IOException("Malformed C line sent by remote SCP binary.");
int length_name_sep = line.indexOf(' ', 5);
if (length_name_sep == -1)
throw new IOException("Malformed C line sent by remote SCP binary.");
String length_substring = line.substring(5, length_name_sep);
String name_substring = line.substring(length_name_sep + 1);
if ((length_substring.length() <= 0) || (name_substring.length() <= 0))
throw new IOException("Malformed C line sent by remote SCP binary.");
if ((6 + length_substring.length() + name_substring.length()) != line.length())
throw new IOException("Malformed C line sent by remote SCP binary.");
try
{
len = Long.parseLong(length_substring);
}
catch (NumberFormatException e)
{
throw new IOException("Malformed C line sent by remote SCP binary, cannot parse file length.");
}
if (len < 0)
throw new IOException("Malformed C line sent by remote SCP binary, illegal file length.");
LenNamePair lnp = new LenNamePair();
lnp.length = len;
lnp.filename = name_substring;
return lnp;
}
private void sendBytes(Session sess, byte[] data, String fileName, String mode) throws IOException
{
OutputStream os = sess.getStdin();
InputStream is = new BufferedInputStream(sess.getStdout(), 512);
readResponse(is);
String cline = "C" + mode + " " + data.length + " " + fileName + "\n";
os.write(cline.getBytes("ISO-8859-1"));
os.flush();
readResponse(is);
os.write(data, 0, data.length);
os.write(0);
os.flush();
readResponse(is);
os.write("E\n".getBytes("ISO-8859-1"));
os.flush();
}
private void sendFiles(Session sess, String[] files, String[] remoteFiles, String mode) throws IOException
{
byte[] buffer = new byte[8192];
OutputStream os = new BufferedOutputStream(sess.getStdin(), 40000);
InputStream is = new BufferedInputStream(sess.getStdout(), 512);
readResponse(is);
for (int i = 0; i < files.length; i++)
{
File f = new File(files[i]);
long remain = f.length();
String remoteName;
if ((remoteFiles != null) && (remoteFiles.length > i) && (remoteFiles[i] != null))
remoteName = remoteFiles[i];
else
remoteName = f.getName();
String cline = "C" + mode + " " + remain + " " + remoteName + "\n";
os.write(cline.getBytes("ISO-8859-1"));
os.flush();
readResponse(is);
FileInputStream fis = null;
try
{
fis = new FileInputStream(f);
while (remain > 0)
{
int trans;
if (remain > buffer.length)
trans = buffer.length;
else
trans = (int) remain;
if (fis.read(buffer, 0, trans) != trans)
throw new IOException("Cannot read enough from local file " + files[i]);
os.write(buffer, 0, trans);
remain -= trans;
}
}
finally
{
if (fis != null)
fis.close();
}
os.write(0);
os.flush();
readResponse(is);
}
os.write("E\n".getBytes("ISO-8859-1"));
os.flush();
}
private void receiveFiles(Session sess, OutputStream[] targets) throws IOException
{
byte[] buffer = new byte[8192];
OutputStream os = new BufferedOutputStream(sess.getStdin(), 512);
InputStream is = new BufferedInputStream(sess.getStdout(), 40000);
os.write(0x0);
os.flush();
for (int i = 0; i < targets.length; i++)
{
LenNamePair lnp = null;
while (true)
{
int c = is.read();
if (c < 0)
throw new IOException("Remote scp terminated unexpectedly.");
String line = receiveLine(is);
if (c == 'T')
{
/* Ignore modification times */
continue;
}
if ((c == 1) || (c == 2))
throw new IOException("Remote SCP error: " + line);
if (c == 'C')
{
lnp = parseCLine(line);
break;
}
throw new IOException("Remote SCP error: " + ((char) c) + line);
}
os.write(0x0);
os.flush();
long remain = lnp.length;
while (remain > 0)
{
int trans;
if (remain > buffer.length)
trans = buffer.length;
else
trans = (int) remain;
int this_time_received = is.read(buffer, 0, trans);
if (this_time_received < 0)
{
throw new IOException("Remote scp terminated connection unexpectedly");
}
targets[i].write(buffer, 0, this_time_received);
remain -= this_time_received;
}
readResponse(is);
os.write(0x0);
os.flush();
}
}
private void receiveFiles(Session sess, String[] files, String target) throws IOException
{
byte[] buffer = new byte[8192];
OutputStream os = new BufferedOutputStream(sess.getStdin(), 512);
InputStream is = new BufferedInputStream(sess.getStdout(), 40000);
os.write(0x0);
os.flush();
for (int i = 0; i < files.length; i++)
{
LenNamePair lnp = null;
while (true)
{
int c = is.read();
if (c < 0)
throw new IOException("Remote scp terminated unexpectedly.");
String line = receiveLine(is);
if (c == 'T')
{
/* Ignore modification times */
continue;
}
if ((c == 1) || (c == 2))
throw new IOException("Remote SCP error: " + line);
if (c == 'C')
{
lnp = parseCLine(line);
break;
}
throw new IOException("Remote SCP error: " + ((char) c) + line);
}
os.write(0x0);
os.flush();
File f = new File(target + File.separatorChar + lnp.filename);
FileOutputStream fop = null;
try
{
fop = new FileOutputStream(f);
long remain = lnp.length;
while (remain > 0)
{
int trans;
if (remain > buffer.length)
trans = buffer.length;
else
trans = (int) remain;
int this_time_received = is.read(buffer, 0, trans);
if (this_time_received < 0)
{
throw new IOException("Remote scp terminated connection unexpectedly");
}
fop.write(buffer, 0, this_time_received);
remain -= this_time_received;
}
}
finally
{
if (fop != null)
fop.close();
}
readResponse(is);
os.write(0x0);
os.flush();
}
}
/**
* Copy a local file to a remote directory, uses mode 0600 when creating the
* file on the remote side.
*
* @param localFile
* Path and name of local file.
* @param remoteTargetDirectory
* Remote target directory. Use an empty string to specify the
* default directory.
*
* @throws IOException
*/
public void put(String localFile, String remoteTargetDirectory) throws IOException
{
put(new String[] { localFile }, remoteTargetDirectory, "0600");
}
/**
* Copy a set of local files to a remote directory, uses mode 0600 when
* creating files on the remote side.
*
* @param localFiles
* Paths and names of local file names.
* @param remoteTargetDirectory
* Remote target directory. Use an empty string to specify the
* default directory.
*
* @throws IOException
*/
public void put(String[] localFiles, String remoteTargetDirectory) throws IOException
{
put(localFiles, remoteTargetDirectory, "0600");
}
/**
* Copy a local file to a remote directory, uses the specified mode when
* creating the file on the remote side.
*
* @param localFile
* Path and name of local file.
* @param remoteTargetDirectory
* Remote target directory. Use an empty string to specify the
* default directory.
* @param mode
* a four digit string (e.g., 0644, see "man chmod", "man open")
* @throws IOException
*/
public void put(String localFile, String remoteTargetDirectory, String mode) throws IOException
{
put(new String[] { localFile }, remoteTargetDirectory, mode);
}
/**
* Copy a local file to a remote directory, uses the specified mode and
* remote filename when creating the file on the remote side.
*
* @param localFile
* Path and name of local file.
* @param remoteFileName
* The name of the file which will be created in the remote
* target directory.
* @param remoteTargetDirectory
* Remote target directory. Use an empty string to specify the
* default directory.
* @param mode
* a four digit string (e.g., 0644, see "man chmod", "man open")
* @throws IOException
*/
public void put(String localFile, String remoteFileName, String remoteTargetDirectory, String mode)
throws IOException
{
put(new String[] { localFile }, new String[] { remoteFileName }, remoteTargetDirectory, mode);
}
/**
* Create a remote file and copy the contents of the passed byte array into
* it. Uses mode 0600 for creating the remote file.
*
* @param data
* the data to be copied into the remote file.
* @param remoteFileName
* The name of the file which will be created in the remote
* target directory.
* @param remoteTargetDirectory
* Remote target directory. Use an empty string to specify the
* default directory.
* @throws IOException
*/
public void put(byte[] data, String remoteFileName, String remoteTargetDirectory) throws IOException
{
put(data, remoteFileName, remoteTargetDirectory, "0600");
}
/**
* Create a remote file and copy the contents of the passed byte array into
* it. The method use the specified mode when creating the file on the
* remote side.
*
* @param data
* the data to be copied into the remote file.
* @param remoteFileName
* The name of the file which will be created in the remote
* target directory.
* @param remoteTargetDirectory
* Remote target directory. Use an empty string to specify the
* default directory.
* @param mode
* a four digit string (e.g., 0644, see "man chmod", "man open")
* @throws IOException
*/
public void put(byte[] data, String remoteFileName, String remoteTargetDirectory, String mode) throws IOException
{
Session sess = null;
if ((remoteFileName == null) || (remoteTargetDirectory == null) || (mode == null))
throw new IllegalArgumentException("Null argument.");
if (mode.length() != 4)
throw new IllegalArgumentException("Invalid mode.");
for (int i = 0; i < mode.length(); i++)
if (Character.isDigit(mode.charAt(i)) == false)
throw new IllegalArgumentException("Invalid mode.");
remoteTargetDirectory = remoteTargetDirectory.trim();
remoteTargetDirectory = (remoteTargetDirectory.length() > 0) ? remoteTargetDirectory : ".";
String cmd = "scp -t -d " + remoteTargetDirectory;
try
{
sess = conn.openSession();
sess.execCommand(cmd);
sendBytes(sess, data, remoteFileName, mode);
}
catch (IOException e)
{
throw (IOException) new IOException("Error during SCP transfer.").initCause(e);
}
finally
{
if (sess != null)
sess.close();
}
}
/**
* Copy a set of local files to a remote directory, uses the specified mode
* when creating the files on the remote side.
*
* @param localFiles
* Paths and names of the local files.
* @param remoteTargetDirectory
* Remote target directory. Use an empty string to specify the
* default directory.
* @param mode
* a four digit string (e.g., 0644, see "man chmod", "man open")
* @throws IOException
*/
public void put(String[] localFiles, String remoteTargetDirectory, String mode) throws IOException
{
put(localFiles, null, remoteTargetDirectory, mode);
}
public void put(String[] localFiles, String[] remoteFiles, String remoteTargetDirectory, String mode)
throws IOException
{
Session sess = null;
/*
* remoteFiles may be null, indicating that the local filenames shall be
* used
*/
if ((localFiles == null) || (remoteTargetDirectory == null) || (mode == null))
throw new IllegalArgumentException("Null argument.");
if (mode.length() != 4)
throw new IllegalArgumentException("Invalid mode.");
for (int i = 0; i < mode.length(); i++)
if (Character.isDigit(mode.charAt(i)) == false)
throw new IllegalArgumentException("Invalid mode.");
if (localFiles.length == 0)
return;
remoteTargetDirectory = remoteTargetDirectory.trim();
remoteTargetDirectory = (remoteTargetDirectory.length() > 0) ? remoteTargetDirectory : ".";
String cmd = "scp -t -d " + remoteTargetDirectory;
for (int i = 0; i < localFiles.length; i++)
{
if (localFiles[i] == null)
throw new IllegalArgumentException("Cannot accept null filename.");
}
try
{
sess = conn.openSession();
sess.execCommand(cmd);
sendFiles(sess, localFiles, remoteFiles, mode);
}
catch (IOException e)
{
throw (IOException) new IOException("Error during SCP transfer.").initCause(e);
}
finally
{
if (sess != null)
sess.close();
}
}
/**
* Download a file from the remote server to a local directory.
*
* @param remoteFile
* Path and name of the remote file.
* @param localTargetDirectory
* Local directory to put the downloaded file.
*
* @throws IOException
*/
public void get(String remoteFile, String localTargetDirectory) throws IOException
{
get(new String[] { remoteFile }, localTargetDirectory);
}
/**
* Download a file from the remote server and pipe its contents into an
* <code>OutputStream</code>. Please note that, to enable flexible usage
* of this method, the <code>OutputStream</code> will not be closed nor
* flushed.
*
* @param remoteFile
* Path and name of the remote file.
* @param target
* OutputStream where the contents of the file will be sent to.
* @throws IOException
*/
public void get(String remoteFile, OutputStream target) throws IOException
{
get(new String[] { remoteFile }, new OutputStream[] { target });
}
private void get(String remoteFiles[], OutputStream[] targets) throws IOException
{
Session sess = null;
if ((remoteFiles == null) || (targets == null))
throw new IllegalArgumentException("Null argument.");
if (remoteFiles.length != targets.length)
throw new IllegalArgumentException("Length of arguments does not match.");
if (remoteFiles.length == 0)
return;
String cmd = "scp -f";
for (int i = 0; i < remoteFiles.length; i++)
{
if (remoteFiles[i] == null)
throw new IllegalArgumentException("Cannot accept null filename.");
String tmp = remoteFiles[i].trim();
if (tmp.length() == 0)
throw new IllegalArgumentException("Cannot accept empty filename.");
cmd += (" " + tmp);
}
try
{
sess = conn.openSession();
sess.execCommand(cmd);
receiveFiles(sess, targets);
}
catch (IOException e)
{
throw (IOException) new IOException("Error during SCP transfer.").initCause(e);
}
finally
{
if (sess != null)
sess.close();
}
}
/**
* Download a set of files from the remote server to a local directory.
*
* @param remoteFiles
* Paths and names of the remote files.
* @param localTargetDirectory
* Local directory to put the downloaded files.
*
* @throws IOException
*/
public void get(String remoteFiles[], String localTargetDirectory) throws IOException
{
Session sess = null;
if ((remoteFiles == null) || (localTargetDirectory == null))
throw new IllegalArgumentException("Null argument.");
if (remoteFiles.length == 0)
return;
String cmd = "scp -f";
for (int i = 0; i < remoteFiles.length; i++)
{
if (remoteFiles[i] == null)
throw new IllegalArgumentException("Cannot accept null filename.");
String tmp = remoteFiles[i].trim();
if (tmp.length() == 0)
throw new IllegalArgumentException("Cannot accept empty filename.");
cmd += (" " + tmp);
}
try
{
sess = conn.openSession();
sess.execCommand(cmd);
receiveFiles(sess, remoteFiles, localTargetDirectory);
}
catch (IOException e)
{
throw (IOException) new IOException("Error during SCP transfer.").initCause(e);
}
finally
{
if (sess != null)
sess.close();
}
}
}
| Java |
package com.trilead.ssh2.channel;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
* LocalAcceptThread.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: LocalAcceptThread.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class LocalAcceptThread extends Thread implements IChannelWorkerThread
{
ChannelManager cm;
String host_to_connect;
int port_to_connect;
final ServerSocket ss;
public LocalAcceptThread(ChannelManager cm, int local_port, String host_to_connect, int port_to_connect)
throws IOException
{
this.cm = cm;
this.host_to_connect = host_to_connect;
this.port_to_connect = port_to_connect;
ss = new ServerSocket(local_port);
}
public LocalAcceptThread(ChannelManager cm, InetSocketAddress localAddress, String host_to_connect,
int port_to_connect) throws IOException
{
this.cm = cm;
this.host_to_connect = host_to_connect;
this.port_to_connect = port_to_connect;
ss = new ServerSocket();
ss.bind(localAddress);
}
public void run()
{
try
{
cm.registerThread(this);
}
catch (IOException e)
{
stopWorking();
return;
}
while (true)
{
Socket s = null;
try
{
s = ss.accept();
}
catch (IOException e)
{
stopWorking();
return;
}
Channel cn = null;
StreamForwarder r2l = null;
StreamForwarder l2r = null;
try
{
/* This may fail, e.g., if the remote port is closed (in optimistic terms: not open yet) */
cn = cm.openDirectTCPIPChannel(host_to_connect, port_to_connect, s.getInetAddress().getHostAddress(), s
.getPort());
}
catch (IOException e)
{
/* Simply close the local socket and wait for the next incoming connection */
try
{
s.close();
}
catch (IOException ignore)
{
}
continue;
}
try
{
r2l = new StreamForwarder(cn, null, s, cn.stdoutStream, s.getOutputStream(), "RemoteToLocal");
l2r = new StreamForwarder(cn, r2l, s, s.getInputStream(), cn.stdinStream, "LocalToRemote");
}
catch (IOException e)
{
try
{
/* This message is only visible during debugging, since we discard the channel immediatelly */
cn.cm.closeChannel(cn, "Weird error during creation of StreamForwarder (" + e.getMessage() + ")",
true);
}
catch (IOException ignore)
{
}
continue;
}
r2l.setDaemon(true);
l2r.setDaemon(true);
r2l.start();
l2r.start();
}
}
public void stopWorking()
{
try
{
/* This will lead to an IOException in the ss.accept() call */
ss.close();
}
catch (IOException e)
{
}
}
}
| Java |
package com.trilead.ssh2.channel;
/**
* RemoteForwardingData. Data about a requested remote forwarding.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: RemoteForwardingData.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class RemoteForwardingData
{
public String bindAddress;
public int bindPort;
String targetAddress;
int targetPort;
}
| Java |
package com.trilead.ssh2.channel;
import java.io.IOException;
import java.net.Socket;
import com.trilead.ssh2.log.Logger;
/**
* RemoteAcceptThread.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: RemoteAcceptThread.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class RemoteAcceptThread extends Thread
{
private static final Logger log = Logger.getLogger(RemoteAcceptThread.class);
Channel c;
String remoteConnectedAddress;
int remoteConnectedPort;
String remoteOriginatorAddress;
int remoteOriginatorPort;
String targetAddress;
int targetPort;
Socket s;
public RemoteAcceptThread(Channel c, String remoteConnectedAddress, int remoteConnectedPort,
String remoteOriginatorAddress, int remoteOriginatorPort, String targetAddress, int targetPort)
{
this.c = c;
this.remoteConnectedAddress = remoteConnectedAddress;
this.remoteConnectedPort = remoteConnectedPort;
this.remoteOriginatorAddress = remoteOriginatorAddress;
this.remoteOriginatorPort = remoteOriginatorPort;
this.targetAddress = targetAddress;
this.targetPort = targetPort;
if (log.isEnabled())
log.log(20, "RemoteAcceptThread: " + remoteConnectedAddress + "/" + remoteConnectedPort + ", R: "
+ remoteOriginatorAddress + "/" + remoteOriginatorPort);
}
public void run()
{
try
{
c.cm.sendOpenConfirmation(c);
s = new Socket(targetAddress, targetPort);
StreamForwarder r2l = new StreamForwarder(c, null, s, c.getStdoutStream(), s.getOutputStream(),
"RemoteToLocal");
StreamForwarder l2r = new StreamForwarder(c, null, null, s.getInputStream(), c.getStdinStream(),
"LocalToRemote");
/* No need to start two threads, one can be executed in the current thread */
r2l.setDaemon(true);
r2l.start();
l2r.run();
while (r2l.isAlive())
{
try
{
r2l.join();
}
catch (InterruptedException e)
{
}
}
/* If the channel is already closed, then this is a no-op */
c.cm.closeChannel(c, "EOF on both streams reached.", true);
s.close();
}
catch (IOException e)
{
log.log(50, "IOException in proxy code: " + e.getMessage());
try
{
c.cm.closeChannel(c, "IOException in proxy code (" + e.getMessage() + ")", true);
}
catch (IOException e1)
{
}
try
{
if (s != null)
s.close();
}
catch (IOException e1)
{
}
}
}
}
| Java |
package com.trilead.ssh2.channel;
import java.io.IOException;
import java.io.OutputStream;
/**
* ChannelOutputStream.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: ChannelOutputStream.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public final class ChannelOutputStream extends OutputStream
{
Channel c;
private byte[] writeBuffer;
boolean isClosed = false;
ChannelOutputStream(Channel c)
{
this.c = c;
writeBuffer = new byte[1];
}
public void write(int b) throws IOException
{
writeBuffer[0] = (byte) b;
write(writeBuffer, 0, 1);
}
public void close() throws IOException
{
if (isClosed == false)
{
isClosed = true;
c.cm.sendEOF(c);
}
}
public void flush() throws IOException
{
if (isClosed)
throw new IOException("This OutputStream is closed.");
/* This is a no-op, since this stream is unbuffered */
}
public void write(byte[] b, int off, int len) throws IOException
{
if (isClosed)
throw new IOException("This OutputStream is closed.");
if (b == null)
throw new NullPointerException();
if ((off < 0) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0) || (off > b.length))
throw new IndexOutOfBoundsException();
if (len == 0)
return;
c.cm.sendData(c, b, off, len);
}
public void write(byte[] b) throws IOException
{
write(b, 0, b.length);
}
}
| Java |
package com.trilead.ssh2.channel;
import java.io.IOException;
import java.io.InputStream;
/**
* ChannelInputStream.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: ChannelInputStream.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public final class ChannelInputStream extends InputStream
{
Channel c;
boolean isClosed = false;
boolean isEOF = false;
boolean extendedFlag = false;
ChannelInputStream(Channel c, boolean isExtended)
{
this.c = c;
this.extendedFlag = isExtended;
}
public int available() throws IOException
{
if (isEOF)
return 0;
int avail = c.cm.getAvailable(c, extendedFlag);
/* We must not return -1 on EOF */
return (avail > 0) ? avail : 0;
}
public void close() throws IOException
{
isClosed = true;
}
public int read(byte[] b, int off, int len) throws IOException
{
if (b == null)
throw new NullPointerException();
if ((off < 0) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0) || (off > b.length))
throw new IndexOutOfBoundsException();
if (len == 0)
return 0;
if (isEOF)
return -1;
int ret = c.cm.getChannelData(c, extendedFlag, b, off, len);
if (ret == -1)
{
isEOF = true;
}
return ret;
}
public int read(byte[] b) throws IOException
{
return read(b, 0, b.length);
}
public int read() throws IOException
{
/* Yes, this stream is pure and unbuffered, a single byte read() is slow */
final byte b[] = new byte[1];
int ret = read(b, 0, 1);
if (ret != 1)
return -1;
return b[0] & 0xff;
}
}
| Java |
package com.trilead.ssh2.channel;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
* A StreamForwarder forwards data between two given streams.
* If two StreamForwarder threads are used (one for each direction)
* then one can be configured to shutdown the underlying channel/socket
* if both threads have finished forwarding (EOF).
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: StreamForwarder.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class StreamForwarder extends Thread
{
final OutputStream os;
final InputStream is;
final byte[] buffer = new byte[Channel.CHANNEL_BUFFER_SIZE];
final Channel c;
final StreamForwarder sibling;
final Socket s;
final String mode;
StreamForwarder(Channel c, StreamForwarder sibling, Socket s, InputStream is, OutputStream os, String mode)
throws IOException
{
this.is = is;
this.os = os;
this.mode = mode;
this.c = c;
this.sibling = sibling;
this.s = s;
}
public void run()
{
try
{
while (true)
{
int len = is.read(buffer);
if (len <= 0)
break;
os.write(buffer, 0, len);
os.flush();
}
}
catch (IOException ignore)
{
try
{
c.cm.closeChannel(c, "Closed due to exception in StreamForwarder (" + mode + "): "
+ ignore.getMessage(), true);
}
catch (IOException e)
{
}
}
finally
{
try
{
os.close();
}
catch (IOException e1)
{
}
try
{
is.close();
}
catch (IOException e2)
{
}
if (sibling != null)
{
while (sibling.isAlive())
{
try
{
sibling.join();
}
catch (InterruptedException e)
{
}
}
try
{
c.cm.closeChannel(c, "StreamForwarder (" + mode + ") is cleaning up the connection", true);
}
catch (IOException e3)
{
}
}
if (s != null) {
try
{
s.close();
}
catch (IOException e1)
{
}
}
}
}
}
| Java |
package com.trilead.ssh2.channel;
/**
* X11ServerData. Data regarding an x11 forwarding target.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: X11ServerData.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*
*/
public class X11ServerData
{
public String hostname;
public int port;
public byte[] x11_magic_cookie; /* not the remote (fake) one, the local (real) one */
}
| Java |
package com.trilead.ssh2.channel;
/**
* Channel.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: Channel.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
public class Channel
{
/*
* OK. Here is an important part of the JVM Specification:
* (http://java.sun.com/docs/books/vmspec/2nd-edition/html/Threads.doc.html#22214)
*
* Any association between locks and variables is purely conventional.
* Locking any lock conceptually flushes all variables from a thread's
* working memory, and unlocking any lock forces the writing out to main
* memory of all variables that the thread has assigned. That a lock may be
* associated with a particular object or a class is purely a convention.
* (...)
*
* If a thread uses a particular shared variable only after locking a
* particular lock and before the corresponding unlocking of that same lock,
* then the thread will read the shared value of that variable from main
* memory after the lock operation, if necessary, and will copy back to main
* memory the value most recently assigned to that variable before the
* unlock operation.
*
* This, in conjunction with the mutual exclusion rules for locks, suffices
* to guarantee that values are correctly transmitted from one thread to
* another through shared variables.
*
* ====> Always keep that in mind when modifying the Channel/ChannelManger
* code.
*
*/
static final int STATE_OPENING = 1;
static final int STATE_OPEN = 2;
static final int STATE_CLOSED = 4;
static final int CHANNEL_BUFFER_SIZE = 30000;
/*
* To achieve correctness, the following rules have to be respected when
* accessing this object:
*/
// These fields can always be read
final ChannelManager cm;
final ChannelOutputStream stdinStream;
final ChannelInputStream stdoutStream;
final ChannelInputStream stderrStream;
// These two fields will only be written while the Channel is in state
// STATE_OPENING.
// The code makes sure that the two fields are written out when the state is
// changing to STATE_OPEN.
// Therefore, if you know that the Channel is in state STATE_OPEN, then you
// can read these two fields without synchronizing on the Channel. However, make
// sure that you get the latest values (e.g., flush caches by synchronizing on any
// object). However, to be on the safe side, you can lock the channel.
int localID = -1;
int remoteID = -1;
/*
* Make sure that we never send a data/EOF/WindowChange msg after a CLOSE
* msg.
*
* This is a little bit complicated, but we have to do it in that way, since
* we cannot keep a lock on the Channel during the send operation (this
* would block sometimes the receiver thread, and, in extreme cases, can
* lead to a deadlock on both sides of the connection (senders are blocked
* since the receive buffers on the other side are full, and receiver
* threads wait for the senders to finish). It all depends on the
* implementation on the other side. But we cannot make any assumptions, we
* have to assume the worst case. Confused? Just believe me.
*/
/*
* If you send a message on a channel, then you have to aquire the
* "channelSendLock" and check the "closeMessageSent" flag (this variable
* may only be accessed while holding the "channelSendLock" !!!
*
* BTW: NEVER EVER SEND MESSAGES FROM THE RECEIVE THREAD - see explanation
* above.
*/
final Object channelSendLock = new Object();
boolean closeMessageSent = false;
/*
* Stop memory fragmentation by allocating this often used buffer.
* May only be used while holding the channelSendLock
*/
final byte[] msgWindowAdjust = new byte[9];
// If you access (read or write) any of the following fields, then you have
// to synchronize on the channel.
int state = STATE_OPENING;
boolean closeMessageRecv = false;
/* This is a stupid implementation. At the moment we can only wait
* for one pending request per channel.
*/
int successCounter = 0;
int failedCounter = 0;
int localWindow = 0; /* locally, we use a small window, < 2^31 */
long remoteWindow = 0; /* long for readable 2^32 - 1 window support */
int localMaxPacketSize = -1;
int remoteMaxPacketSize = -1;
final byte[] stdoutBuffer = new byte[CHANNEL_BUFFER_SIZE];
final byte[] stderrBuffer = new byte[CHANNEL_BUFFER_SIZE];
int stdoutReadpos = 0;
int stdoutWritepos = 0;
int stderrReadpos = 0;
int stderrWritepos = 0;
boolean EOF = false;
Integer exit_status;
String exit_signal;
// we keep the x11 cookie so that this channel can be closed when this
// specific x11 forwarding gets stopped
String hexX11FakeCookie;
// reasonClosed is special, since we sometimes need to access it
// while holding the channelSendLock.
// We protect it with a private short term lock.
private final Object reasonClosedLock = new Object();
private String reasonClosed = null;
public Channel(ChannelManager cm)
{
this.cm = cm;
this.localWindow = CHANNEL_BUFFER_SIZE;
this.localMaxPacketSize = 35000 - 1024; // leave enough slack
this.stdinStream = new ChannelOutputStream(this);
this.stdoutStream = new ChannelInputStream(this, false);
this.stderrStream = new ChannelInputStream(this, true);
}
/* Methods to allow access from classes outside of this package */
public ChannelInputStream getStderrStream()
{
return stderrStream;
}
public ChannelOutputStream getStdinStream()
{
return stdinStream;
}
public ChannelInputStream getStdoutStream()
{
return stdoutStream;
}
public String getExitSignal()
{
synchronized (this)
{
return exit_signal;
}
}
public Integer getExitStatus()
{
synchronized (this)
{
return exit_status;
}
}
public String getReasonClosed()
{
synchronized (reasonClosedLock)
{
return reasonClosed;
}
}
public void setReasonClosed(String reasonClosed)
{
synchronized (reasonClosedLock)
{
if (this.reasonClosed == null)
this.reasonClosed = reasonClosed;
}
}
}
| Java |
package com.trilead.ssh2.channel;
/**
* IChannelWorkerThread.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: IChannelWorkerThread.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
*/
interface IChannelWorkerThread
{
public void stopWorking();
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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 com.trilead.ssh2.channel;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.io.PushbackInputStream;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NoRouteToHostException;
import java.net.ServerSocket;
import java.net.Socket;
import net.sourceforge.jsocks.Proxy;
import net.sourceforge.jsocks.ProxyMessage;
import net.sourceforge.jsocks.Socks4Message;
import net.sourceforge.jsocks.Socks5Message;
import net.sourceforge.jsocks.SocksException;
import net.sourceforge.jsocks.server.ServerAuthenticator;
import net.sourceforge.jsocks.server.ServerAuthenticatorNone;
/**
* DynamicAcceptThread.
*
* @author Kenny Root
* @version $Id$
*/
public class DynamicAcceptThread extends Thread implements IChannelWorkerThread {
private ChannelManager cm;
private ServerSocket ss;
class DynamicAcceptRunnable implements Runnable {
private static final int idleTimeout = 180000; //3 minutes
private ServerAuthenticator auth;
private Socket sock;
private InputStream in;
private OutputStream out;
private ProxyMessage msg;
public DynamicAcceptRunnable(ServerAuthenticator auth, Socket sock) {
this.auth = auth;
this.sock = sock;
setName("DynamicAcceptRunnable");
}
public void run() {
try {
startSession();
} catch (IOException ioe) {
int error_code = Proxy.SOCKS_FAILURE;
if (ioe instanceof SocksException)
error_code = ((SocksException) ioe).errCode;
else if (ioe instanceof NoRouteToHostException)
error_code = Proxy.SOCKS_HOST_UNREACHABLE;
else if (ioe instanceof ConnectException)
error_code = Proxy.SOCKS_CONNECTION_REFUSED;
else if (ioe instanceof InterruptedIOException)
error_code = Proxy.SOCKS_TTL_EXPIRE;
if (error_code > Proxy.SOCKS_ADDR_NOT_SUPPORTED
|| error_code < 0) {
error_code = Proxy.SOCKS_FAILURE;
}
sendErrorMessage(error_code);
} finally {
if (auth != null)
auth.endSession();
}
}
private ProxyMessage readMsg(InputStream in) throws IOException {
PushbackInputStream push_in;
if (in instanceof PushbackInputStream)
push_in = (PushbackInputStream) in;
else
push_in = new PushbackInputStream(in);
int version = push_in.read();
push_in.unread(version);
ProxyMessage msg;
if (version == 5) {
msg = new Socks5Message(push_in, false);
} else if (version == 4) {
msg = new Socks4Message(push_in, false);
} else {
throw new SocksException(Proxy.SOCKS_FAILURE);
}
return msg;
}
private void sendErrorMessage(int error_code) {
ProxyMessage err_msg;
if (msg instanceof Socks4Message)
err_msg = new Socks4Message(Socks4Message.REPLY_REJECTED);
else
err_msg = new Socks5Message(error_code);
try {
err_msg.write(out);
} catch (IOException ioe) {
}
}
private void handleRequest(ProxyMessage msg) throws IOException {
if (!auth.checkRequest(msg))
throw new SocksException(Proxy.SOCKS_FAILURE);
switch (msg.command) {
case Proxy.SOCKS_CMD_CONNECT:
onConnect(msg);
break;
default:
throw new SocksException(Proxy.SOCKS_CMD_NOT_SUPPORTED);
}
}
private void startSession() throws IOException {
sock.setSoTimeout(idleTimeout);
try {
auth = auth.startSession(sock);
} catch (IOException ioe) {
System.out.println("Could not start SOCKS session");
ioe.printStackTrace();
auth = null;
return;
}
if (auth == null) { // Authentication failed
System.out.println("SOCKS auth failed");
return;
}
in = auth.getInputStream();
out = auth.getOutputStream();
msg = readMsg(in);
handleRequest(msg);
}
private void onConnect(ProxyMessage msg) throws IOException {
ProxyMessage response = null;
Channel cn = null;
StreamForwarder r2l = null;
StreamForwarder l2r = null;
if (msg instanceof Socks5Message) {
response = new Socks5Message(Proxy.SOCKS_SUCCESS, (InetAddress)null, 0);
} else {
response = new Socks4Message(Socks4Message.REPLY_OK, (InetAddress)null, 0);
}
response.write(out);
String destHost = msg.host;
if (msg.ip != null)
destHost = msg.ip.getHostAddress();
try {
/*
* This may fail, e.g., if the remote port is closed (in
* optimistic terms: not open yet)
*/
cn = cm.openDirectTCPIPChannel(destHost, msg.port,
"127.0.0.1", 0);
} catch (IOException e) {
/*
* Simply close the local socket and wait for the next incoming
* connection
*/
try {
sock.close();
} catch (IOException ignore) {
}
return;
}
try {
r2l = new StreamForwarder(cn, null, sock, cn.stdoutStream, out, "RemoteToLocal");
l2r = new StreamForwarder(cn, r2l, sock, in, cn.stdinStream, "LocalToRemote");
} catch (IOException e) {
try {
/*
* This message is only visible during debugging, since we
* discard the channel immediatelly
*/
cn.cm.closeChannel(cn,
"Weird error during creation of StreamForwarder ("
+ e.getMessage() + ")", true);
} catch (IOException ignore) {
}
return;
}
r2l.setDaemon(true);
l2r.setDaemon(true);
r2l.start();
l2r.start();
}
}
public DynamicAcceptThread(ChannelManager cm, int local_port)
throws IOException {
this.cm = cm;
setName("DynamicAcceptThread");
ss = new ServerSocket(local_port);
}
public DynamicAcceptThread(ChannelManager cm, InetSocketAddress localAddress)
throws IOException {
this.cm = cm;
ss = new ServerSocket();
ss.bind(localAddress);
}
@Override
public void run() {
try {
cm.registerThread(this);
} catch (IOException e) {
stopWorking();
return;
}
while (true) {
Socket sock = null;
try {
sock = ss.accept();
} catch (IOException e) {
stopWorking();
return;
}
DynamicAcceptRunnable dar = new DynamicAcceptRunnable(new ServerAuthenticatorNone(), sock);
Thread t = new Thread(dar);
t.setDaemon(true);
t.start();
}
}
/*
* (non-Javadoc)
*
* @see com.trilead.ssh2.channel.IChannelWorkerThread#stopWorking()
*/
public void stopWorking() {
try {
/* This will lead to an IOException in the ss.accept() call */
ss.close();
} catch (IOException e) {
}
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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 com.trilead.ssh2.channel;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.Map;
import java.util.Map.Entry;
import com.trilead.ssh2.AuthAgentCallback;
import com.trilead.ssh2.log.Logger;
import com.trilead.ssh2.packets.TypesReader;
import com.trilead.ssh2.packets.TypesWriter;
import com.trilead.ssh2.signature.DSAPrivateKey;
import com.trilead.ssh2.signature.DSASHA1Verify;
import com.trilead.ssh2.signature.DSASignature;
import com.trilead.ssh2.signature.RSAPrivateKey;
import com.trilead.ssh2.signature.RSASHA1Verify;
import com.trilead.ssh2.signature.RSASignature;
/**
* AuthAgentForwardThread.
*
* @author Kenny Root
* @version $Id$
*/
public class AuthAgentForwardThread extends Thread implements IChannelWorkerThread
{
private static final byte[] SSH_AGENT_FAILURE = {0, 0, 0, 1, 5}; // 5
private static final byte[] SSH_AGENT_SUCCESS = {0, 0, 0, 1, 6}; // 6
private static final int SSH2_AGENTC_REQUEST_IDENTITIES = 11;
private static final int SSH2_AGENT_IDENTITIES_ANSWER = 12;
private static final int SSH2_AGENTC_SIGN_REQUEST = 13;
private static final int SSH2_AGENT_SIGN_RESPONSE = 14;
private static final int SSH2_AGENTC_ADD_IDENTITY = 17;
private static final int SSH2_AGENTC_REMOVE_IDENTITY = 18;
private static final int SSH2_AGENTC_REMOVE_ALL_IDENTITIES = 19;
// private static final int SSH_AGENTC_ADD_SMARTCARD_KEY = 20;
// private static final int SSH_AGENTC_REMOVE_SMARTCARD_KEY = 21;
private static final int SSH_AGENTC_LOCK = 22;
private static final int SSH_AGENTC_UNLOCK = 23;
private static final int SSH2_AGENTC_ADD_ID_CONSTRAINED = 25;
// private static final int SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED = 26;
// Constraints for adding keys
private static final int SSH_AGENT_CONSTRAIN_LIFETIME = 1;
private static final int SSH_AGENT_CONSTRAIN_CONFIRM = 2;
// Flags for signature requests
// private static final int SSH_AGENT_OLD_SIGNATURE = 1;
private static final Logger log = Logger.getLogger(RemoteAcceptThread.class);
AuthAgentCallback authAgent;
OutputStream os;
InputStream is;
Channel c;
byte[] buffer = new byte[Channel.CHANNEL_BUFFER_SIZE];
public AuthAgentForwardThread(Channel c, AuthAgentCallback authAgent)
{
this.c = c;
this.authAgent = authAgent;
if (log.isEnabled())
log.log(20, "AuthAgentForwardThread started");
}
@Override
public void run()
{
try
{
c.cm.registerThread(this);
}
catch (IOException e)
{
stopWorking();
return;
}
try
{
c.cm.sendOpenConfirmation(c);
is = c.getStdoutStream();
os = c.getStdinStream();
int totalSize = 4;
int readSoFar = 0;
while (true) {
int len;
try
{
len = is.read(buffer, readSoFar, buffer.length - readSoFar);
}
catch (IOException e)
{
stopWorking();
return;
}
if (len <= 0)
break;
readSoFar += len;
if (readSoFar >= 4) {
TypesReader tr = new TypesReader(buffer, 0, 4);
totalSize = tr.readUINT32() + 4;
}
if (totalSize == readSoFar) {
TypesReader tr = new TypesReader(buffer, 4, readSoFar - 4);
int messageType = tr.readByte();
switch (messageType) {
case SSH2_AGENTC_REQUEST_IDENTITIES:
sendIdentities();
break;
case SSH2_AGENTC_ADD_IDENTITY:
addIdentity(tr, false);
break;
case SSH2_AGENTC_ADD_ID_CONSTRAINED:
addIdentity(tr, true);
break;
case SSH2_AGENTC_REMOVE_IDENTITY:
removeIdentity(tr);
break;
case SSH2_AGENTC_REMOVE_ALL_IDENTITIES:
removeAllIdentities(tr);
break;
case SSH2_AGENTC_SIGN_REQUEST:
processSignRequest(tr);
break;
case SSH_AGENTC_LOCK:
processLockRequest(tr);
break;
case SSH_AGENTC_UNLOCK:
processUnlockRequest(tr);
break;
default:
os.write(SSH_AGENT_FAILURE);
break;
}
readSoFar = 0;
}
}
c.cm.closeChannel(c, "EOF on both streams reached.", true);
}
catch (IOException e)
{
log.log(50, "IOException in agent forwarder: " + e.getMessage());
try
{
is.close();
}
catch (IOException e1)
{
}
try
{
os.close();
}
catch (IOException e2)
{
}
try
{
c.cm.closeChannel(c, "IOException in agent forwarder (" + e.getMessage() + ")", true);
}
catch (IOException e3)
{
}
}
}
public void stopWorking() {
try
{
/* This will lead to an IOException in the is.read() call */
is.close();
}
catch (IOException e)
{
}
}
/**
* @return whether the agent is locked
*/
private boolean failWhenLocked() throws IOException
{
if (authAgent.isAgentLocked()) {
os.write(SSH_AGENT_FAILURE);
return true;
} else
return false;
}
private void sendIdentities() throws IOException
{
Map<String,byte[]> keys = null;
TypesWriter tw = new TypesWriter();
tw.writeByte(SSH2_AGENT_IDENTITIES_ANSWER);
int numKeys = 0;
if (!authAgent.isAgentLocked())
keys = authAgent.retrieveIdentities();
if (keys != null)
numKeys = keys.size();
tw.writeUINT32(numKeys);
if (keys != null) {
for (Entry<String,byte[]> entry : keys.entrySet()) {
byte[] keyBytes = entry.getValue();
tw.writeString(keyBytes, 0, keyBytes.length);
tw.writeString(entry.getKey());
}
}
sendPacket(tw.getBytes());
}
/**
* @param tr
*/
private void addIdentity(TypesReader tr, boolean checkConstraints) {
try
{
if (failWhenLocked())
return;
String type = tr.readString();
Object key;
String comment;
if (type.equals("ssh-rsa")) {
BigInteger n = tr.readMPINT();
BigInteger e = tr.readMPINT();
BigInteger d = tr.readMPINT();
tr.readMPINT(); // iqmp
tr.readMPINT(); // p
tr.readMPINT(); // q
comment = tr.readString();
key = new RSAPrivateKey(d, e, n);
} else if (type.equals("ssh-dss")) {
BigInteger p = tr.readMPINT();
BigInteger q = tr.readMPINT();
BigInteger g = tr.readMPINT();
BigInteger y = tr.readMPINT();
BigInteger x = tr.readMPINT();
comment = tr.readString();
key = new DSAPrivateKey(p, q, g, y, x);
} else {
os.write(SSH_AGENT_FAILURE);
return;
}
boolean confirmUse = false;
int lifetime = 0;
if (checkConstraints) {
while (tr.remain() > 0) {
int constraint = tr.readByte();
if (constraint == SSH_AGENT_CONSTRAIN_CONFIRM)
confirmUse = true;
else if (constraint == SSH_AGENT_CONSTRAIN_LIFETIME)
lifetime = tr.readUINT32();
else {
// Unknown constraint. Bail.
os.write(SSH_AGENT_FAILURE);
return;
}
}
}
if (authAgent.addIdentity(key, comment, confirmUse, lifetime))
os.write(SSH_AGENT_SUCCESS);
else
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e)
{
try
{
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e1)
{
}
}
}
/**
* @param tr
*/
private void removeIdentity(TypesReader tr) {
try
{
if (failWhenLocked())
return;
byte[] publicKey = tr.readByteString();
if (authAgent.removeIdentity(publicKey))
os.write(SSH_AGENT_SUCCESS);
else
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e)
{
try
{
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e1)
{
}
}
}
/**
* @param tr
*/
private void removeAllIdentities(TypesReader tr) {
try
{
if (failWhenLocked())
return;
if (authAgent.removeAllIdentities())
os.write(SSH_AGENT_SUCCESS);
else
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e)
{
try
{
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e1)
{
}
}
}
private void processSignRequest(TypesReader tr)
{
try
{
if (failWhenLocked())
return;
byte[] publicKey = tr.readByteString();
byte[] challenge = tr.readByteString();
int flags = tr.readUINT32();
if (flags != 0) {
// We don't understand any flags; abort!
os.write(SSH_AGENT_FAILURE);
return;
}
Object trileadKey = authAgent.getPrivateKey(publicKey);
if (trileadKey == null) {
os.write(SSH_AGENT_FAILURE);
return;
}
byte[] response;
if (trileadKey instanceof RSAPrivateKey) {
RSASignature signature = RSASHA1Verify.generateSignature(challenge,
(RSAPrivateKey) trileadKey);
response = RSASHA1Verify.encodeSSHRSASignature(signature);
} else if (trileadKey instanceof DSAPrivateKey) {
DSASignature signature = DSASHA1Verify.generateSignature(challenge,
(DSAPrivateKey) trileadKey, new SecureRandom());
response = DSASHA1Verify.encodeSSHDSASignature(signature);
} else {
os.write(SSH_AGENT_FAILURE);
return;
}
TypesWriter tw = new TypesWriter();
tw.writeByte(SSH2_AGENT_SIGN_RESPONSE);
tw.writeString(response, 0, response.length);
sendPacket(tw.getBytes());
}
catch (IOException e)
{
try
{
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e1)
{
}
}
}
/**
* @param tr
*/
private void processLockRequest(TypesReader tr) {
try
{
if (failWhenLocked())
return;
String lockPassphrase = tr.readString();
if (!authAgent.setAgentLock(lockPassphrase)) {
os.write(SSH_AGENT_FAILURE);
return;
} else
os.write(SSH_AGENT_SUCCESS);
}
catch (IOException e)
{
try
{
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e1)
{
}
}
}
/**
* @param tr
*/
private void processUnlockRequest(TypesReader tr)
{
try
{
String unlockPassphrase = tr.readString();
if (authAgent.requestAgentUnlock(unlockPassphrase))
os.write(SSH_AGENT_SUCCESS);
else
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e)
{
try
{
os.write(SSH_AGENT_FAILURE);
}
catch (IOException e1)
{
}
}
}
/**
* @param tw
* @throws IOException
*/
private void sendPacket(byte[] message) throws IOException
{
TypesWriter packet = new TypesWriter();
packet.writeUINT32(message.length);
packet.writeBytes(message);
os.write(packet.getBytes());
}
}
| Java |
package com.trilead.ssh2.channel;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import com.trilead.ssh2.log.Logger;
/**
* RemoteX11AcceptThread.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: RemoteX11AcceptThread.java,v 1.2 2008/04/01 12:38:09 cplattne Exp $
*/
public class RemoteX11AcceptThread extends Thread
{
private static final Logger log = Logger.getLogger(RemoteX11AcceptThread.class);
Channel c;
String remoteOriginatorAddress;
int remoteOriginatorPort;
Socket s;
public RemoteX11AcceptThread(Channel c, String remoteOriginatorAddress, int remoteOriginatorPort)
{
this.c = c;
this.remoteOriginatorAddress = remoteOriginatorAddress;
this.remoteOriginatorPort = remoteOriginatorPort;
}
public void run()
{
try
{
/* Send Open Confirmation */
c.cm.sendOpenConfirmation(c);
/* Read startup packet from client */
OutputStream remote_os = c.getStdinStream();
InputStream remote_is = c.getStdoutStream();
/* The following code is based on the protocol description given in:
* Scheifler/Gettys,
* X Windows System: Core and Extension Protocols:
* X Version 11, Releases 6 and 6.1 ISBN 1-55558-148-X
*/
/*
* Client startup:
*
* 1 0X42 MSB first/0x6c lSB first - byteorder
* 1 - unused
* 2 card16 - protocol-major-version
* 2 card16 - protocol-minor-version
* 2 n - lenght of authorization-protocol-name
* 2 d - lenght of authorization-protocol-data
* 2 - unused
* string8 - authorization-protocol-name
* p - unused, p=pad(n)
* string8 - authorization-protocol-data
* q - unused, q=pad(d)
*
* pad(X) = (4 - (X mod 4)) mod 4
*
* Server response:
*
* 1 (0 failed, 2 authenticate, 1 success)
* ...
*
*/
/* Later on we will simply forward the first 6 header bytes to the "real" X11 server */
byte[] header = new byte[6];
if (remote_is.read(header) != 6)
throw new IOException("Unexpected EOF on X11 startup!");
if ((header[0] != 0x42) && (header[0] != 0x6c)) // 0x42 MSB first, 0x6C LSB first
throw new IOException("Unknown endian format in X11 message!");
/* Yes, I came up with this myself - shall I file an application for a patent? =) */
int idxMSB = (header[0] == 0x42) ? 0 : 1;
/* Read authorization data header */
byte[] auth_buff = new byte[6];
if (remote_is.read(auth_buff) != 6)
throw new IOException("Unexpected EOF on X11 startup!");
int authProtocolNameLength = ((auth_buff[idxMSB] & 0xff) << 8) | (auth_buff[1 - idxMSB] & 0xff);
int authProtocolDataLength = ((auth_buff[2 + idxMSB] & 0xff) << 8) | (auth_buff[3 - idxMSB] & 0xff);
if ((authProtocolNameLength > 256) || (authProtocolDataLength > 256))
throw new IOException("Buggy X11 authorization data");
int authProtocolNamePadding = ((4 - (authProtocolNameLength % 4)) % 4);
int authProtocolDataPadding = ((4 - (authProtocolDataLength % 4)) % 4);
byte[] authProtocolName = new byte[authProtocolNameLength];
byte[] authProtocolData = new byte[authProtocolDataLength];
byte[] paddingBuffer = new byte[4];
if (remote_is.read(authProtocolName) != authProtocolNameLength)
throw new IOException("Unexpected EOF on X11 startup! (authProtocolName)");
if (remote_is.read(paddingBuffer, 0, authProtocolNamePadding) != authProtocolNamePadding)
throw new IOException("Unexpected EOF on X11 startup! (authProtocolNamePadding)");
if (remote_is.read(authProtocolData) != authProtocolDataLength)
throw new IOException("Unexpected EOF on X11 startup! (authProtocolData)");
if (remote_is.read(paddingBuffer, 0, authProtocolDataPadding) != authProtocolDataPadding)
throw new IOException("Unexpected EOF on X11 startup! (authProtocolDataPadding)");
if ("MIT-MAGIC-COOKIE-1".equals(new String(authProtocolName, "ISO-8859-1")) == false)
throw new IOException("Unknown X11 authorization protocol!");
if (authProtocolDataLength != 16)
throw new IOException("Wrong data length for X11 authorization data!");
StringBuffer tmp = new StringBuffer(32);
for (int i = 0; i < authProtocolData.length; i++)
{
String digit2 = Integer.toHexString(authProtocolData[i] & 0xff);
tmp.append((digit2.length() == 2) ? digit2 : "0" + digit2);
}
String hexEncodedFakeCookie = tmp.toString();
/* Order is very important here - it may be that a certain x11 forwarding
* gets disabled right in the moment when we check and register our connection
* */
synchronized (c)
{
/* Please read the comment in Channel.java */
c.hexX11FakeCookie = hexEncodedFakeCookie;
}
/* Now check our fake cookie directory to see if we produced this cookie */
X11ServerData sd = c.cm.checkX11Cookie(hexEncodedFakeCookie);
if (sd == null)
throw new IOException("Invalid X11 cookie received.");
/* If the session which corresponds to this cookie is closed then we will
* detect this: the session's close code will close all channels
* with the session's assigned x11 fake cookie.
*/
s = new Socket(sd.hostname, sd.port);
OutputStream x11_os = s.getOutputStream();
InputStream x11_is = s.getInputStream();
/* Now we are sending the startup packet to the real X11 server */
x11_os.write(header);
if (sd.x11_magic_cookie == null)
{
byte[] emptyAuthData = new byte[6];
/* empty auth data, hopefully you are connecting to localhost =) */
x11_os.write(emptyAuthData);
}
else
{
if (sd.x11_magic_cookie.length != 16)
throw new IOException("The real X11 cookie has an invalid length!");
/* send X11 cookie specified by client */
x11_os.write(auth_buff);
x11_os.write(authProtocolName); /* re-use */
x11_os.write(paddingBuffer, 0, authProtocolNamePadding);
x11_os.write(sd.x11_magic_cookie);
x11_os.write(paddingBuffer, 0, authProtocolDataPadding);
}
x11_os.flush();
/* Start forwarding traffic */
StreamForwarder r2l = new StreamForwarder(c, null, s, remote_is, x11_os, "RemoteToX11");
StreamForwarder l2r = new StreamForwarder(c, null, null, x11_is, remote_os, "X11ToRemote");
/* No need to start two threads, one can be executed in the current thread */
r2l.setDaemon(true);
r2l.start();
l2r.run();
while (r2l.isAlive())
{
try
{
r2l.join();
}
catch (InterruptedException e)
{
}
}
/* If the channel is already closed, then this is a no-op */
c.cm.closeChannel(c, "EOF on both X11 streams reached.", true);
s.close();
}
catch (IOException e)
{
log.log(50, "IOException in X11 proxy code: " + e.getMessage());
try
{
c.cm.closeChannel(c, "IOException in X11 proxy code (" + e.getMessage() + ")", true);
}
catch (IOException e1)
{
}
try
{
if (s != null)
s.close();
}
catch (IOException e1)
{
}
}
}
}
| Java |
package com.trilead.ssh2.channel;
import java.io.IOException;
import java.util.HashMap;
import java.util.Vector;
import com.trilead.ssh2.AuthAgentCallback;
import com.trilead.ssh2.ChannelCondition;
import com.trilead.ssh2.log.Logger;
import com.trilead.ssh2.packets.PacketChannelAuthAgentReq;
import com.trilead.ssh2.packets.PacketChannelOpenConfirmation;
import com.trilead.ssh2.packets.PacketChannelOpenFailure;
import com.trilead.ssh2.packets.PacketChannelTrileadPing;
import com.trilead.ssh2.packets.PacketGlobalCancelForwardRequest;
import com.trilead.ssh2.packets.PacketGlobalForwardRequest;
import com.trilead.ssh2.packets.PacketGlobalTrileadPing;
import com.trilead.ssh2.packets.PacketOpenDirectTCPIPChannel;
import com.trilead.ssh2.packets.PacketOpenSessionChannel;
import com.trilead.ssh2.packets.PacketSessionExecCommand;
import com.trilead.ssh2.packets.PacketSessionPtyRequest;
import com.trilead.ssh2.packets.PacketSessionPtyResize;
import com.trilead.ssh2.packets.PacketSessionStartShell;
import com.trilead.ssh2.packets.PacketSessionSubsystemRequest;
import com.trilead.ssh2.packets.PacketSessionX11Request;
import com.trilead.ssh2.packets.Packets;
import com.trilead.ssh2.packets.TypesReader;
import com.trilead.ssh2.transport.MessageHandler;
import com.trilead.ssh2.transport.TransportManager;
/**
* ChannelManager. Please read the comments in Channel.java.
* <p>
* Besides the crypto part, this is the core of the library.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: ChannelManager.java,v 1.2 2008/03/03 07:01:36 cplattne Exp $
*/
public class ChannelManager implements MessageHandler
{
private static final Logger log = Logger.getLogger(ChannelManager.class);
private HashMap x11_magic_cookies = new HashMap();
private TransportManager tm;
private Vector channels = new Vector();
private int nextLocalChannel = 100;
private boolean shutdown = false;
private int globalSuccessCounter = 0;
private int globalFailedCounter = 0;
private HashMap remoteForwardings = new HashMap();
private AuthAgentCallback authAgent;
private Vector listenerThreads = new Vector();
private boolean listenerThreadsAllowed = true;
public ChannelManager(TransportManager tm)
{
this.tm = tm;
tm.registerMessageHandler(this, 80, 100);
}
private Channel getChannel(int id)
{
synchronized (channels)
{
for (int i = 0; i < channels.size(); i++)
{
Channel c = (Channel) channels.elementAt(i);
if (c.localID == id)
return c;
}
}
return null;
}
private void removeChannel(int id)
{
synchronized (channels)
{
for (int i = 0; i < channels.size(); i++)
{
Channel c = (Channel) channels.elementAt(i);
if (c.localID == id)
{
channels.removeElementAt(i);
break;
}
}
}
}
private int addChannel(Channel c)
{
synchronized (channels)
{
channels.addElement(c);
return nextLocalChannel++;
}
}
private void waitUntilChannelOpen(Channel c) throws IOException
{
synchronized (c)
{
while (c.state == Channel.STATE_OPENING)
{
try
{
c.wait();
}
catch (InterruptedException ignore)
{
}
}
if (c.state != Channel.STATE_OPEN)
{
removeChannel(c.localID);
String detail = c.getReasonClosed();
if (detail == null)
detail = "state: " + c.state;
throw new IOException("Could not open channel (" + detail + ")");
}
}
}
private final boolean waitForGlobalRequestResult() throws IOException
{
synchronized (channels)
{
while ((globalSuccessCounter == 0) && (globalFailedCounter == 0))
{
if (shutdown)
{
throw new IOException("The connection is being shutdown");
}
try
{
channels.wait();
}
catch (InterruptedException ignore)
{
}
}
if ((globalFailedCounter == 0) && (globalSuccessCounter == 1))
return true;
if ((globalFailedCounter == 1) && (globalSuccessCounter == 0))
return false;
throw new IOException("Illegal state. The server sent " + globalSuccessCounter
+ " SSH_MSG_REQUEST_SUCCESS and " + globalFailedCounter + " SSH_MSG_REQUEST_FAILURE messages.");
}
}
private final boolean waitForChannelRequestResult(Channel c) throws IOException
{
synchronized (c)
{
while ((c.successCounter == 0) && (c.failedCounter == 0))
{
if (c.state != Channel.STATE_OPEN)
{
String detail = c.getReasonClosed();
if (detail == null)
detail = "state: " + c.state;
throw new IOException("This SSH2 channel is not open (" + detail + ")");
}
try
{
c.wait();
}
catch (InterruptedException ignore)
{
}
}
if ((c.failedCounter == 0) && (c.successCounter == 1))
return true;
if ((c.failedCounter == 1) && (c.successCounter == 0))
return false;
throw new IOException("Illegal state. The server sent " + c.successCounter
+ " SSH_MSG_CHANNEL_SUCCESS and " + c.failedCounter + " SSH_MSG_CHANNEL_FAILURE messages.");
}
}
public void registerX11Cookie(String hexFakeCookie, X11ServerData data)
{
synchronized (x11_magic_cookies)
{
x11_magic_cookies.put(hexFakeCookie, data);
}
}
public void unRegisterX11Cookie(String hexFakeCookie, boolean killChannels)
{
if (hexFakeCookie == null)
throw new IllegalStateException("hexFakeCookie may not be null");
synchronized (x11_magic_cookies)
{
x11_magic_cookies.remove(hexFakeCookie);
}
if (killChannels == false)
return;
if (log.isEnabled())
log.log(50, "Closing all X11 channels for the given fake cookie");
Vector channel_copy;
synchronized (channels)
{
channel_copy = (Vector) channels.clone();
}
for (int i = 0; i < channel_copy.size(); i++)
{
Channel c = (Channel) channel_copy.elementAt(i);
synchronized (c)
{
if (hexFakeCookie.equals(c.hexX11FakeCookie) == false)
continue;
}
try
{
closeChannel(c, "Closing X11 channel since the corresponding session is closing", true);
}
catch (IOException e)
{
}
}
}
public X11ServerData checkX11Cookie(String hexFakeCookie)
{
synchronized (x11_magic_cookies)
{
if (hexFakeCookie != null)
return (X11ServerData) x11_magic_cookies.get(hexFakeCookie);
}
return null;
}
public void closeAllChannels()
{
if (log.isEnabled())
log.log(50, "Closing all channels");
Vector channel_copy;
synchronized (channels)
{
channel_copy = (Vector) channels.clone();
}
for (int i = 0; i < channel_copy.size(); i++)
{
Channel c = (Channel) channel_copy.elementAt(i);
try
{
closeChannel(c, "Closing all channels", true);
}
catch (IOException e)
{
}
}
}
public void closeChannel(Channel c, String reason, boolean force) throws IOException
{
byte msg[] = new byte[5];
synchronized (c)
{
if (force)
{
c.state = Channel.STATE_CLOSED;
c.EOF = true;
}
c.setReasonClosed(reason);
msg[0] = Packets.SSH_MSG_CHANNEL_CLOSE;
msg[1] = (byte) (c.remoteID >> 24);
msg[2] = (byte) (c.remoteID >> 16);
msg[3] = (byte) (c.remoteID >> 8);
msg[4] = (byte) (c.remoteID);
c.notifyAll();
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent == true)
return;
tm.sendMessage(msg);
c.closeMessageSent = true;
}
if (log.isEnabled())
log.log(50, "Sent SSH_MSG_CHANNEL_CLOSE (channel " + c.localID + ")");
}
public void sendEOF(Channel c) throws IOException
{
byte[] msg = new byte[5];
synchronized (c)
{
if (c.state != Channel.STATE_OPEN)
return;
msg[0] = Packets.SSH_MSG_CHANNEL_EOF;
msg[1] = (byte) (c.remoteID >> 24);
msg[2] = (byte) (c.remoteID >> 16);
msg[3] = (byte) (c.remoteID >> 8);
msg[4] = (byte) (c.remoteID);
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent == true)
return;
tm.sendMessage(msg);
}
if (log.isEnabled())
log.log(50, "Sent EOF (Channel " + c.localID + "/" + c.remoteID + ")");
}
public void sendOpenConfirmation(Channel c) throws IOException
{
PacketChannelOpenConfirmation pcoc = null;
synchronized (c)
{
if (c.state != Channel.STATE_OPENING)
return;
c.state = Channel.STATE_OPEN;
pcoc = new PacketChannelOpenConfirmation(c.remoteID, c.localID, c.localWindow, c.localMaxPacketSize);
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent == true)
return;
tm.sendMessage(pcoc.getPayload());
}
}
public void sendData(Channel c, byte[] buffer, int pos, int len) throws IOException
{
while (len > 0)
{
int thislen = 0;
byte[] msg;
synchronized (c)
{
while (true)
{
if (c.state == Channel.STATE_CLOSED)
throw new IOException("SSH channel is closed. (" + c.getReasonClosed() + ")");
if (c.state != Channel.STATE_OPEN)
throw new IOException("SSH channel in strange state. (" + c.state + ")");
if (c.remoteWindow != 0)
break;
try
{
c.wait();
}
catch (InterruptedException ignore)
{
}
}
/* len > 0, no sign extension can happen when comparing */
thislen = (c.remoteWindow >= len) ? len : (int) c.remoteWindow;
int estimatedMaxDataLen = c.remoteMaxPacketSize - (tm.getPacketOverheadEstimate() + 9);
/* The worst case scenario =) a true bottleneck */
if (estimatedMaxDataLen <= 0)
{
estimatedMaxDataLen = 1;
}
if (thislen > estimatedMaxDataLen)
thislen = estimatedMaxDataLen;
c.remoteWindow -= thislen;
msg = new byte[1 + 8 + thislen];
msg[0] = Packets.SSH_MSG_CHANNEL_DATA;
msg[1] = (byte) (c.remoteID >> 24);
msg[2] = (byte) (c.remoteID >> 16);
msg[3] = (byte) (c.remoteID >> 8);
msg[4] = (byte) (c.remoteID);
msg[5] = (byte) (thislen >> 24);
msg[6] = (byte) (thislen >> 16);
msg[7] = (byte) (thislen >> 8);
msg[8] = (byte) (thislen);
System.arraycopy(buffer, pos, msg, 9, thislen);
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent == true)
throw new IOException("SSH channel is closed. (" + c.getReasonClosed() + ")");
tm.sendMessage(msg);
}
pos += thislen;
len -= thislen;
}
}
public int requestGlobalForward(String bindAddress, int bindPort, String targetAddress, int targetPort)
throws IOException
{
RemoteForwardingData rfd = new RemoteForwardingData();
rfd.bindAddress = bindAddress;
rfd.bindPort = bindPort;
rfd.targetAddress = targetAddress;
rfd.targetPort = targetPort;
synchronized (remoteForwardings)
{
Integer key = new Integer(bindPort);
if (remoteForwardings.get(key) != null)
{
throw new IOException("There is already a forwarding for remote port " + bindPort);
}
remoteForwardings.put(key, rfd);
}
synchronized (channels)
{
globalSuccessCounter = globalFailedCounter = 0;
}
PacketGlobalForwardRequest pgf = new PacketGlobalForwardRequest(true, bindAddress, bindPort);
tm.sendMessage(pgf.getPayload());
if (log.isEnabled())
log.log(50, "Requesting a remote forwarding ('" + bindAddress + "', " + bindPort + ")");
try
{
if (waitForGlobalRequestResult() == false)
throw new IOException("The server denied the request (did you enable port forwarding?)");
}
catch (IOException e)
{
synchronized (remoteForwardings)
{
remoteForwardings.remove(rfd);
}
throw e;
}
return bindPort;
}
public void requestCancelGlobalForward(int bindPort) throws IOException
{
RemoteForwardingData rfd = null;
synchronized (remoteForwardings)
{
rfd = (RemoteForwardingData) remoteForwardings.get(new Integer(bindPort));
if (rfd == null)
throw new IOException("Sorry, there is no known remote forwarding for remote port " + bindPort);
}
synchronized (channels)
{
globalSuccessCounter = globalFailedCounter = 0;
}
PacketGlobalCancelForwardRequest pgcf = new PacketGlobalCancelForwardRequest(true, rfd.bindAddress,
rfd.bindPort);
tm.sendMessage(pgcf.getPayload());
if (log.isEnabled())
log.log(50, "Requesting cancelation of remote forward ('" + rfd.bindAddress + "', " + rfd.bindPort + ")");
try
{
if (waitForGlobalRequestResult() == false)
throw new IOException("The server denied the request.");
}
finally
{
synchronized (remoteForwardings)
{
/* Only now we are sure that no more forwarded connections will arrive */
remoteForwardings.remove(rfd);
}
}
}
/**
* @param agent
* @throws IOException
*/
public boolean requestChannelAgentForwarding(Channel c, AuthAgentCallback authAgent) throws IOException {
synchronized (this)
{
if (this.authAgent != null)
throw new IllegalStateException("Auth agent already exists");
this.authAgent = authAgent;
}
synchronized (channels)
{
globalSuccessCounter = globalFailedCounter = 0;
}
if (log.isEnabled())
log.log(50, "Requesting agent forwarding");
PacketChannelAuthAgentReq aar = new PacketChannelAuthAgentReq(c.remoteID);
tm.sendMessage(aar.getPayload());
if (waitForChannelRequestResult(c) == false) {
authAgent = null;
return false;
}
return true;
}
public void registerThread(IChannelWorkerThread thr) throws IOException
{
synchronized (listenerThreads)
{
if (listenerThreadsAllowed == false)
throw new IOException("Too late, this connection is closed.");
listenerThreads.addElement(thr);
}
}
public Channel openDirectTCPIPChannel(String host_to_connect, int port_to_connect, String originator_IP_address,
int originator_port) throws IOException
{
Channel c = new Channel(this);
synchronized (c)
{
c.localID = addChannel(c);
// end of synchronized block forces writing out to main memory
}
PacketOpenDirectTCPIPChannel dtc = new PacketOpenDirectTCPIPChannel(c.localID, c.localWindow,
c.localMaxPacketSize, host_to_connect, port_to_connect, originator_IP_address, originator_port);
tm.sendMessage(dtc.getPayload());
waitUntilChannelOpen(c);
return c;
}
public Channel openSessionChannel() throws IOException
{
Channel c = new Channel(this);
synchronized (c)
{
c.localID = addChannel(c);
// end of synchronized block forces the writing out to main memory
}
if (log.isEnabled())
log.log(50, "Sending SSH_MSG_CHANNEL_OPEN (Channel " + c.localID + ")");
PacketOpenSessionChannel smo = new PacketOpenSessionChannel(c.localID, c.localWindow, c.localMaxPacketSize);
tm.sendMessage(smo.getPayload());
waitUntilChannelOpen(c);
return c;
}
public void requestGlobalTrileadPing() throws IOException
{
synchronized (channels)
{
globalSuccessCounter = globalFailedCounter = 0;
}
PacketGlobalTrileadPing pgtp = new PacketGlobalTrileadPing();
tm.sendMessage(pgtp.getPayload());
if (log.isEnabled())
log.log(50, "Sending SSH_MSG_GLOBAL_REQUEST 'trilead-ping'.");
try
{
if (waitForGlobalRequestResult() == true)
throw new IOException("Your server is alive - but buggy. "
+ "It replied with SSH_MSG_REQUEST_SUCCESS when it actually should not.");
}
catch (IOException e)
{
throw (IOException) new IOException("The ping request failed.").initCause(e);
}
}
public void requestChannelTrileadPing(Channel c) throws IOException
{
PacketChannelTrileadPing pctp;
synchronized (c)
{
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot ping this channel (" + c.getReasonClosed() + ")");
pctp = new PacketChannelTrileadPing(c.remoteID);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent)
throw new IOException("Cannot ping this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(pctp.getPayload());
}
try
{
if (waitForChannelRequestResult(c) == true)
throw new IOException("Your server is alive - but buggy. "
+ "It replied with SSH_MSG_SESSION_SUCCESS when it actually should not.");
}
catch (IOException e)
{
throw (IOException) new IOException("The ping request failed.").initCause(e);
}
}
public void requestPTY(Channel c, String term, int term_width_characters, int term_height_characters,
int term_width_pixels, int term_height_pixels, byte[] terminal_modes) throws IOException
{
PacketSessionPtyRequest spr;
synchronized (c)
{
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot request PTY on this channel (" + c.getReasonClosed() + ")");
spr = new PacketSessionPtyRequest(c.remoteID, true, term, term_width_characters, term_height_characters,
term_width_pixels, term_height_pixels, terminal_modes);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent)
throw new IOException("Cannot request PTY on this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(spr.getPayload());
}
try
{
if (waitForChannelRequestResult(c) == false)
throw new IOException("The server denied the request.");
}
catch (IOException e)
{
throw (IOException) new IOException("PTY request failed").initCause(e);
}
}
public void resizePTY(Channel c, int term_width_characters, int term_height_characters,
int term_width_pixels, int term_height_pixels) throws IOException {
PacketSessionPtyResize spr;
synchronized (c) {
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot request PTY on this channel ("
+ c.getReasonClosed() + ")");
spr = new PacketSessionPtyResize(c.remoteID, term_width_characters, term_height_characters,
term_width_pixels, term_height_pixels);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock) {
if (c.closeMessageSent)
throw new IOException("Cannot request PTY on this channel ("
+ c.getReasonClosed() + ")");
tm.sendMessage(spr.getPayload());
}
}
public void requestX11(Channel c, boolean singleConnection, String x11AuthenticationProtocol,
String x11AuthenticationCookie, int x11ScreenNumber) throws IOException
{
PacketSessionX11Request psr;
synchronized (c)
{
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot request X11 on this channel (" + c.getReasonClosed() + ")");
psr = new PacketSessionX11Request(c.remoteID, true, singleConnection, x11AuthenticationProtocol,
x11AuthenticationCookie, x11ScreenNumber);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent)
throw new IOException("Cannot request X11 on this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(psr.getPayload());
}
if (log.isEnabled())
log.log(50, "Requesting X11 forwarding (Channel " + c.localID + "/" + c.remoteID + ")");
try
{
if (waitForChannelRequestResult(c) == false)
throw new IOException("The server denied the request.");
}
catch (IOException e)
{
throw (IOException) new IOException("The X11 request failed.").initCause(e);
}
}
public void requestSubSystem(Channel c, String subSystemName) throws IOException
{
PacketSessionSubsystemRequest ssr;
synchronized (c)
{
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot request subsystem on this channel (" + c.getReasonClosed() + ")");
ssr = new PacketSessionSubsystemRequest(c.remoteID, true, subSystemName);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent)
throw new IOException("Cannot request subsystem on this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(ssr.getPayload());
}
try
{
if (waitForChannelRequestResult(c) == false)
throw new IOException("The server denied the request.");
}
catch (IOException e)
{
throw (IOException) new IOException("The subsystem request failed.").initCause(e);
}
}
public void requestExecCommand(Channel c, String cmd) throws IOException
{
PacketSessionExecCommand sm;
synchronized (c)
{
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot execute command on this channel (" + c.getReasonClosed() + ")");
sm = new PacketSessionExecCommand(c.remoteID, true, cmd);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent)
throw new IOException("Cannot execute command on this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(sm.getPayload());
}
if (log.isEnabled())
log.log(50, "Executing command (channel " + c.localID + ", '" + cmd + "')");
try
{
if (waitForChannelRequestResult(c) == false)
throw new IOException("The server denied the request.");
}
catch (IOException e)
{
throw (IOException) new IOException("The execute request failed.").initCause(e);
}
}
public void requestShell(Channel c) throws IOException
{
PacketSessionStartShell sm;
synchronized (c)
{
if (c.state != Channel.STATE_OPEN)
throw new IOException("Cannot start shell on this channel (" + c.getReasonClosed() + ")");
sm = new PacketSessionStartShell(c.remoteID, true);
c.successCounter = c.failedCounter = 0;
}
synchronized (c.channelSendLock)
{
if (c.closeMessageSent)
throw new IOException("Cannot start shell on this channel (" + c.getReasonClosed() + ")");
tm.sendMessage(sm.getPayload());
}
try
{
if (waitForChannelRequestResult(c) == false)
throw new IOException("The server denied the request.");
}
catch (IOException e)
{
throw (IOException) new IOException("The shell request failed.").initCause(e);
}
}
public void msgChannelExtendedData(byte[] msg, int msglen) throws IOException
{
if (msglen <= 13)
throw new IOException("SSH_MSG_CHANNEL_EXTENDED_DATA message has wrong size (" + msglen + ")");
int id = ((msg[1] & 0xff) << 24) | ((msg[2] & 0xff) << 16) | ((msg[3] & 0xff) << 8) | (msg[4] & 0xff);
int dataType = ((msg[5] & 0xff) << 24) | ((msg[6] & 0xff) << 16) | ((msg[7] & 0xff) << 8) | (msg[8] & 0xff);
int len = ((msg[9] & 0xff) << 24) | ((msg[10] & 0xff) << 16) | ((msg[11] & 0xff) << 8) | (msg[12] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_EXTENDED_DATA message for non-existent channel " + id);
if (dataType != Packets.SSH_EXTENDED_DATA_STDERR)
throw new IOException("SSH_MSG_CHANNEL_EXTENDED_DATA message has unknown type (" + dataType + ")");
if (len != (msglen - 13))
throw new IOException("SSH_MSG_CHANNEL_EXTENDED_DATA message has wrong len (calculated " + (msglen - 13)
+ ", got " + len + ")");
if (log.isEnabled())
log.log(80, "Got SSH_MSG_CHANNEL_EXTENDED_DATA (channel " + id + ", " + len + ")");
synchronized (c)
{
if (c.state == Channel.STATE_CLOSED)
return; // ignore
if (c.state != Channel.STATE_OPEN)
throw new IOException("Got SSH_MSG_CHANNEL_EXTENDED_DATA, but channel is not in correct state ("
+ c.state + ")");
if (c.localWindow < len)
throw new IOException("Remote sent too much data, does not fit into window.");
c.localWindow -= len;
System.arraycopy(msg, 13, c.stderrBuffer, c.stderrWritepos, len);
c.stderrWritepos += len;
c.notifyAll();
}
}
/**
* Wait until for a condition.
*
* @param c
* Channel
* @param timeout
* in ms, 0 means no timeout.
* @param condition_mask
* minimum event mask
* @return all current events
*
*/
public int waitForCondition(Channel c, long timeout, int condition_mask)
{
long end_time = 0;
boolean end_time_set = false;
synchronized (c)
{
while (true)
{
int current_cond = 0;
int stdoutAvail = c.stdoutWritepos - c.stdoutReadpos;
int stderrAvail = c.stderrWritepos - c.stderrReadpos;
if (stdoutAvail > 0)
current_cond = current_cond | ChannelCondition.STDOUT_DATA;
if (stderrAvail > 0)
current_cond = current_cond | ChannelCondition.STDERR_DATA;
if (c.EOF)
current_cond = current_cond | ChannelCondition.EOF;
if (c.getExitStatus() != null)
current_cond = current_cond | ChannelCondition.EXIT_STATUS;
if (c.getExitSignal() != null)
current_cond = current_cond | ChannelCondition.EXIT_SIGNAL;
if (c.state == Channel.STATE_CLOSED)
return current_cond | ChannelCondition.CLOSED | ChannelCondition.EOF;
if ((current_cond & condition_mask) != 0)
return current_cond;
if (timeout > 0)
{
if (!end_time_set)
{
end_time = System.currentTimeMillis() + timeout;
end_time_set = true;
}
else
{
timeout = end_time - System.currentTimeMillis();
if (timeout <= 0)
return current_cond | ChannelCondition.TIMEOUT;
}
}
try
{
if (timeout > 0)
c.wait(timeout);
else
c.wait();
}
catch (InterruptedException e)
{
}
}
}
}
public int getAvailable(Channel c, boolean extended) throws IOException
{
synchronized (c)
{
int avail;
if (extended)
avail = c.stderrWritepos - c.stderrReadpos;
else
avail = c.stdoutWritepos - c.stdoutReadpos;
return ((avail > 0) ? avail : (c.EOF ? -1 : 0));
}
}
public int getChannelData(Channel c, boolean extended, byte[] target, int off, int len) throws IOException
{
int copylen = 0;
int increment = 0;
int remoteID = 0;
int localID = 0;
synchronized (c)
{
int stdoutAvail = 0;
int stderrAvail = 0;
while (true)
{
/*
* Data available? We have to return remaining data even if the
* channel is already closed.
*/
stdoutAvail = c.stdoutWritepos - c.stdoutReadpos;
stderrAvail = c.stderrWritepos - c.stderrReadpos;
if ((!extended) && (stdoutAvail != 0))
break;
if ((extended) && (stderrAvail != 0))
break;
/* Do not wait if more data will never arrive (EOF or CLOSED) */
if ((c.EOF) || (c.state != Channel.STATE_OPEN))
return -1;
try
{
c.wait();
}
catch (InterruptedException ignore)
{
}
}
/* OK, there is some data. Return it. */
if (!extended)
{
copylen = (stdoutAvail > len) ? len : stdoutAvail;
System.arraycopy(c.stdoutBuffer, c.stdoutReadpos, target, off, copylen);
c.stdoutReadpos += copylen;
if (c.stdoutReadpos != c.stdoutWritepos)
System.arraycopy(c.stdoutBuffer, c.stdoutReadpos, c.stdoutBuffer, 0, c.stdoutWritepos
- c.stdoutReadpos);
c.stdoutWritepos -= c.stdoutReadpos;
c.stdoutReadpos = 0;
}
else
{
copylen = (stderrAvail > len) ? len : stderrAvail;
System.arraycopy(c.stderrBuffer, c.stderrReadpos, target, off, copylen);
c.stderrReadpos += copylen;
if (c.stderrReadpos != c.stderrWritepos)
System.arraycopy(c.stderrBuffer, c.stderrReadpos, c.stderrBuffer, 0, c.stderrWritepos
- c.stderrReadpos);
c.stderrWritepos -= c.stderrReadpos;
c.stderrReadpos = 0;
}
if (c.state != Channel.STATE_OPEN)
return copylen;
if (c.localWindow < ((Channel.CHANNEL_BUFFER_SIZE + 1) / 2))
{
int minFreeSpace = Math.min(Channel.CHANNEL_BUFFER_SIZE - c.stdoutWritepos, Channel.CHANNEL_BUFFER_SIZE
- c.stderrWritepos);
increment = minFreeSpace - c.localWindow;
c.localWindow = minFreeSpace;
}
remoteID = c.remoteID; /* read while holding the lock */
localID = c.localID; /* read while holding the lock */
}
/*
* If a consumer reads stdout and stdin in parallel, we may end up with
* sending two msgWindowAdjust messages. Luckily, it
* does not matter in which order they arrive at the server.
*/
if (increment > 0)
{
if (log.isEnabled())
log.log(80, "Sending SSH_MSG_CHANNEL_WINDOW_ADJUST (channel " + localID + ", " + increment + ")");
synchronized (c.channelSendLock)
{
byte[] msg = c.msgWindowAdjust;
msg[0] = Packets.SSH_MSG_CHANNEL_WINDOW_ADJUST;
msg[1] = (byte) (remoteID >> 24);
msg[2] = (byte) (remoteID >> 16);
msg[3] = (byte) (remoteID >> 8);
msg[4] = (byte) (remoteID);
msg[5] = (byte) (increment >> 24);
msg[6] = (byte) (increment >> 16);
msg[7] = (byte) (increment >> 8);
msg[8] = (byte) (increment);
if (c.closeMessageSent == false)
tm.sendMessage(msg);
}
}
return copylen;
}
public void msgChannelData(byte[] msg, int msglen) throws IOException
{
if (msglen <= 9)
throw new IOException("SSH_MSG_CHANNEL_DATA message has wrong size (" + msglen + ")");
int id = ((msg[1] & 0xff) << 24) | ((msg[2] & 0xff) << 16) | ((msg[3] & 0xff) << 8) | (msg[4] & 0xff);
int len = ((msg[5] & 0xff) << 24) | ((msg[6] & 0xff) << 16) | ((msg[7] & 0xff) << 8) | (msg[8] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_DATA message for non-existent channel " + id);
if (len != (msglen - 9))
throw new IOException("SSH_MSG_CHANNEL_DATA message has wrong len (calculated " + (msglen - 9) + ", got "
+ len + ")");
if (log.isEnabled())
log.log(80, "Got SSH_MSG_CHANNEL_DATA (channel " + id + ", " + len + ")");
synchronized (c)
{
if (c.state == Channel.STATE_CLOSED)
return; // ignore
if (c.state != Channel.STATE_OPEN)
throw new IOException("Got SSH_MSG_CHANNEL_DATA, but channel is not in correct state (" + c.state + ")");
if (c.localWindow < len)
throw new IOException("Remote sent too much data, does not fit into window.");
c.localWindow -= len;
System.arraycopy(msg, 9, c.stdoutBuffer, c.stdoutWritepos, len);
c.stdoutWritepos += len;
c.notifyAll();
}
}
public void msgChannelWindowAdjust(byte[] msg, int msglen) throws IOException
{
if (msglen != 9)
throw new IOException("SSH_MSG_CHANNEL_WINDOW_ADJUST message has wrong size (" + msglen + ")");
int id = ((msg[1] & 0xff) << 24) | ((msg[2] & 0xff) << 16) | ((msg[3] & 0xff) << 8) | (msg[4] & 0xff);
int windowChange = ((msg[5] & 0xff) << 24) | ((msg[6] & 0xff) << 16) | ((msg[7] & 0xff) << 8) | (msg[8] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_WINDOW_ADJUST message for non-existent channel " + id);
synchronized (c)
{
final long huge = 0xFFFFffffL; /* 2^32 - 1 */
c.remoteWindow += (windowChange & huge); /* avoid sign extension */
/* TODO - is this a good heuristic? */
if ((c.remoteWindow > huge))
c.remoteWindow = huge;
c.notifyAll();
}
if (log.isEnabled())
log.log(80, "Got SSH_MSG_CHANNEL_WINDOW_ADJUST (channel " + id + ", " + windowChange + ")");
}
public void msgChannelOpen(byte[] msg, int msglen) throws IOException
{
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
String channelType = tr.readString();
int remoteID = tr.readUINT32(); /* sender channel */
int remoteWindow = tr.readUINT32(); /* initial window size */
int remoteMaxPacketSize = tr.readUINT32(); /* maximum packet size */
if ("x11".equals(channelType))
{
synchronized (x11_magic_cookies)
{
/* If we did not request X11 forwarding, then simply ignore this bogus request. */
if (x11_magic_cookies.size() == 0)
{
PacketChannelOpenFailure pcof = new PacketChannelOpenFailure(remoteID,
Packets.SSH_OPEN_ADMINISTRATIVELY_PROHIBITED, "X11 forwarding not activated", "");
tm.sendAsynchronousMessage(pcof.getPayload());
if (log.isEnabled())
log.log(20, "Unexpected X11 request, denying it!");
return;
}
}
String remoteOriginatorAddress = tr.readString();
int remoteOriginatorPort = tr.readUINT32();
Channel c = new Channel(this);
synchronized (c)
{
c.remoteID = remoteID;
c.remoteWindow = remoteWindow & 0xFFFFffffL; /* properly convert UINT32 to long */
c.remoteMaxPacketSize = remoteMaxPacketSize;
c.localID = addChannel(c);
}
/*
* The open confirmation message will be sent from another thread
*/
RemoteX11AcceptThread rxat = new RemoteX11AcceptThread(c, remoteOriginatorAddress, remoteOriginatorPort);
rxat.setDaemon(true);
rxat.start();
return;
}
if ("forwarded-tcpip".equals(channelType))
{
String remoteConnectedAddress = tr.readString(); /* address that was connected */
int remoteConnectedPort = tr.readUINT32(); /* port that was connected */
String remoteOriginatorAddress = tr.readString(); /* originator IP address */
int remoteOriginatorPort = tr.readUINT32(); /* originator port */
RemoteForwardingData rfd = null;
synchronized (remoteForwardings)
{
rfd = (RemoteForwardingData) remoteForwardings.get(new Integer(remoteConnectedPort));
}
if (rfd == null)
{
PacketChannelOpenFailure pcof = new PacketChannelOpenFailure(remoteID,
Packets.SSH_OPEN_ADMINISTRATIVELY_PROHIBITED,
"No thanks, unknown port in forwarded-tcpip request", "");
/* Always try to be polite. */
tm.sendAsynchronousMessage(pcof.getPayload());
if (log.isEnabled())
log.log(20, "Unexpected forwarded-tcpip request, denying it!");
return;
}
Channel c = new Channel(this);
synchronized (c)
{
c.remoteID = remoteID;
c.remoteWindow = remoteWindow & 0xFFFFffffL; /* convert UINT32 to long */
c.remoteMaxPacketSize = remoteMaxPacketSize;
c.localID = addChannel(c);
}
/*
* The open confirmation message will be sent from another thread.
*/
RemoteAcceptThread rat = new RemoteAcceptThread(c, remoteConnectedAddress, remoteConnectedPort,
remoteOriginatorAddress, remoteOriginatorPort, rfd.targetAddress, rfd.targetPort);
rat.setDaemon(true);
rat.start();
return;
}
if ("auth-agent@openssh.com".equals(channelType)) {
Channel c = new Channel(this);
synchronized (c)
{
c.remoteID = remoteID;
c.remoteWindow = remoteWindow & 0xFFFFffffL; /* properly convert UINT32 to long */
c.remoteMaxPacketSize = remoteMaxPacketSize;
c.localID = addChannel(c);
}
AuthAgentForwardThread aat = new AuthAgentForwardThread(c, authAgent);
aat.setDaemon(true);
aat.start();
return;
}
/* Tell the server that we have no idea what it is talking about */
PacketChannelOpenFailure pcof = new PacketChannelOpenFailure(remoteID, Packets.SSH_OPEN_UNKNOWN_CHANNEL_TYPE,
"Unknown channel type", "");
tm.sendAsynchronousMessage(pcof.getPayload());
if (log.isEnabled())
log.log(20, "The peer tried to open an unsupported channel type (" + channelType + ")");
}
public void msgChannelRequest(byte[] msg, int msglen) throws IOException
{
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
int id = tr.readUINT32();
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_REQUEST message for non-existent channel " + id);
String type = tr.readString("US-ASCII");
boolean wantReply = tr.readBoolean();
if (log.isEnabled())
log.log(80, "Got SSH_MSG_CHANNEL_REQUEST (channel " + id + ", '" + type + "')");
if (type.equals("exit-status"))
{
if (wantReply != false)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message, 'want reply' is true");
int exit_status = tr.readUINT32();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
synchronized (c)
{
c.exit_status = new Integer(exit_status);
c.notifyAll();
}
if (log.isEnabled())
log.log(50, "Got EXIT STATUS (channel " + id + ", status " + exit_status + ")");
return;
}
if (type.equals("exit-signal"))
{
if (wantReply != false)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message, 'want reply' is true");
String signame = tr.readString("US-ASCII");
tr.readBoolean();
tr.readString();
tr.readString();
if (tr.remain() != 0)
throw new IOException("Badly formatted SSH_MSG_CHANNEL_REQUEST message");
synchronized (c)
{
c.exit_signal = signame;
c.notifyAll();
}
if (log.isEnabled())
log.log(50, "Got EXIT SIGNAL (channel " + id + ", signal " + signame + ")");
return;
}
/* We simply ignore unknown channel requests, however, if the server wants a reply,
* then we signal that we have no idea what it is about.
*/
if (wantReply)
{
byte[] reply = new byte[5];
reply[0] = Packets.SSH_MSG_CHANNEL_FAILURE;
reply[1] = (byte) (c.remoteID >> 24);
reply[2] = (byte) (c.remoteID >> 16);
reply[3] = (byte) (c.remoteID >> 8);
reply[4] = (byte) (c.remoteID);
tm.sendAsynchronousMessage(reply);
}
if (log.isEnabled())
log.log(50, "Channel request '" + type + "' is not known, ignoring it");
}
public void msgChannelEOF(byte[] msg, int msglen) throws IOException
{
if (msglen != 5)
throw new IOException("SSH_MSG_CHANNEL_EOF message has wrong size (" + msglen + ")");
int id = ((msg[1] & 0xff) << 24) | ((msg[2] & 0xff) << 16) | ((msg[3] & 0xff) << 8) | (msg[4] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_EOF message for non-existent channel " + id);
synchronized (c)
{
c.EOF = true;
c.notifyAll();
}
if (log.isEnabled())
log.log(50, "Got SSH_MSG_CHANNEL_EOF (channel " + id + ")");
}
public void msgChannelClose(byte[] msg, int msglen) throws IOException
{
if (msglen != 5)
throw new IOException("SSH_MSG_CHANNEL_CLOSE message has wrong size (" + msglen + ")");
int id = ((msg[1] & 0xff) << 24) | ((msg[2] & 0xff) << 16) | ((msg[3] & 0xff) << 8) | (msg[4] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_CLOSE message for non-existent channel " + id);
synchronized (c)
{
c.EOF = true;
c.state = Channel.STATE_CLOSED;
c.setReasonClosed("Close requested by remote");
c.closeMessageRecv = true;
removeChannel(c.localID);
c.notifyAll();
}
if (log.isEnabled())
log.log(50, "Got SSH_MSG_CHANNEL_CLOSE (channel " + id + ")");
}
public void msgChannelSuccess(byte[] msg, int msglen) throws IOException
{
if (msglen != 5)
throw new IOException("SSH_MSG_CHANNEL_SUCCESS message has wrong size (" + msglen + ")");
int id = ((msg[1] & 0xff) << 24) | ((msg[2] & 0xff) << 16) | ((msg[3] & 0xff) << 8) | (msg[4] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_SUCCESS message for non-existent channel " + id);
synchronized (c)
{
c.successCounter++;
c.notifyAll();
}
if (log.isEnabled())
log.log(80, "Got SSH_MSG_CHANNEL_SUCCESS (channel " + id + ")");
}
public void msgChannelFailure(byte[] msg, int msglen) throws IOException
{
if (msglen != 5)
throw new IOException("SSH_MSG_CHANNEL_FAILURE message has wrong size (" + msglen + ")");
int id = ((msg[1] & 0xff) << 24) | ((msg[2] & 0xff) << 16) | ((msg[3] & 0xff) << 8) | (msg[4] & 0xff);
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_FAILURE message for non-existent channel " + id);
synchronized (c)
{
c.failedCounter++;
c.notifyAll();
}
if (log.isEnabled())
log.log(50, "Got SSH_MSG_CHANNEL_FAILURE (channel " + id + ")");
}
public void msgChannelOpenConfirmation(byte[] msg, int msglen) throws IOException
{
PacketChannelOpenConfirmation sm = new PacketChannelOpenConfirmation(msg, 0, msglen);
Channel c = getChannel(sm.recipientChannelID);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_OPEN_CONFIRMATION message for non-existent channel "
+ sm.recipientChannelID);
synchronized (c)
{
if (c.state != Channel.STATE_OPENING)
throw new IOException("Unexpected SSH_MSG_CHANNEL_OPEN_CONFIRMATION message for channel "
+ sm.recipientChannelID);
c.remoteID = sm.senderChannelID;
c.remoteWindow = sm.initialWindowSize & 0xFFFFffffL; /* convert UINT32 to long */
c.remoteMaxPacketSize = sm.maxPacketSize;
c.state = Channel.STATE_OPEN;
c.notifyAll();
}
if (log.isEnabled())
log.log(50, "Got SSH_MSG_CHANNEL_OPEN_CONFIRMATION (channel " + sm.recipientChannelID + " / remote: "
+ sm.senderChannelID + ")");
}
public void msgChannelOpenFailure(byte[] msg, int msglen) throws IOException
{
if (msglen < 5)
throw new IOException("SSH_MSG_CHANNEL_OPEN_FAILURE message has wrong size (" + msglen + ")");
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
int id = tr.readUINT32(); /* sender channel */
Channel c = getChannel(id);
if (c == null)
throw new IOException("Unexpected SSH_MSG_CHANNEL_OPEN_FAILURE message for non-existent channel " + id);
int reasonCode = tr.readUINT32();
String description = tr.readString("UTF-8");
String reasonCodeSymbolicName = null;
switch (reasonCode)
{
case 1:
reasonCodeSymbolicName = "SSH_OPEN_ADMINISTRATIVELY_PROHIBITED";
break;
case 2:
reasonCodeSymbolicName = "SSH_OPEN_CONNECT_FAILED";
break;
case 3:
reasonCodeSymbolicName = "SSH_OPEN_UNKNOWN_CHANNEL_TYPE";
break;
case 4:
reasonCodeSymbolicName = "SSH_OPEN_RESOURCE_SHORTAGE";
break;
default:
reasonCodeSymbolicName = "UNKNOWN REASON CODE (" + reasonCode + ")";
}
StringBuffer descriptionBuffer = new StringBuffer();
descriptionBuffer.append(description);
for (int i = 0; i < descriptionBuffer.length(); i++)
{
char cc = descriptionBuffer.charAt(i);
if ((cc >= 32) && (cc <= 126))
continue;
descriptionBuffer.setCharAt(i, '\uFFFD');
}
synchronized (c)
{
c.EOF = true;
c.state = Channel.STATE_CLOSED;
c.setReasonClosed("The server refused to open the channel (" + reasonCodeSymbolicName + ", '"
+ descriptionBuffer.toString() + "')");
c.notifyAll();
}
if (log.isEnabled())
log.log(50, "Got SSH_MSG_CHANNEL_OPEN_FAILURE (channel " + id + ")");
}
public void msgGlobalRequest(byte[] msg, int msglen) throws IOException
{
/* Currently we do not support any kind of global request */
TypesReader tr = new TypesReader(msg, 0, msglen);
tr.readByte(); // skip packet type
String requestName = tr.readString();
boolean wantReply = tr.readBoolean();
if (wantReply)
{
byte[] reply_failure = new byte[1];
reply_failure[0] = Packets.SSH_MSG_REQUEST_FAILURE;
tm.sendAsynchronousMessage(reply_failure);
}
/* We do not clean up the requestName String - that is OK for debug */
if (log.isEnabled())
log.log(80, "Got SSH_MSG_GLOBAL_REQUEST (" + requestName + ")");
}
public void msgGlobalSuccess() throws IOException
{
synchronized (channels)
{
globalSuccessCounter++;
channels.notifyAll();
}
if (log.isEnabled())
log.log(80, "Got SSH_MSG_REQUEST_SUCCESS");
}
public void msgGlobalFailure() throws IOException
{
synchronized (channels)
{
globalFailedCounter++;
channels.notifyAll();
}
if (log.isEnabled())
log.log(80, "Got SSH_MSG_REQUEST_FAILURE");
}
public void handleMessage(byte[] msg, int msglen) throws IOException
{
if (msg == null)
{
if (log.isEnabled())
log.log(50, "HandleMessage: got shutdown");
synchronized (listenerThreads)
{
for (int i = 0; i < listenerThreads.size(); i++)
{
IChannelWorkerThread lat = (IChannelWorkerThread) listenerThreads.elementAt(i);
lat.stopWorking();
}
listenerThreadsAllowed = false;
}
synchronized (channels)
{
shutdown = true;
for (int i = 0; i < channels.size(); i++)
{
Channel c = (Channel) channels.elementAt(i);
synchronized (c)
{
c.EOF = true;
c.state = Channel.STATE_CLOSED;
c.setReasonClosed("The connection is being shutdown");
c.closeMessageRecv = true; /*
* You never know, perhaps
* we are waiting for a
* pending close message
* from the server...
*/
c.notifyAll();
}
}
/* Works with J2ME */
channels.setSize(0);
channels.trimToSize();
channels.notifyAll(); /* Notify global response waiters */
return;
}
}
switch (msg[0])
{
case Packets.SSH_MSG_CHANNEL_OPEN_CONFIRMATION:
msgChannelOpenConfirmation(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_WINDOW_ADJUST:
msgChannelWindowAdjust(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_DATA:
msgChannelData(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_EXTENDED_DATA:
msgChannelExtendedData(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_REQUEST:
msgChannelRequest(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_EOF:
msgChannelEOF(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_OPEN:
msgChannelOpen(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_CLOSE:
msgChannelClose(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_SUCCESS:
msgChannelSuccess(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_FAILURE:
msgChannelFailure(msg, msglen);
break;
case Packets.SSH_MSG_CHANNEL_OPEN_FAILURE:
msgChannelOpenFailure(msg, msglen);
break;
case Packets.SSH_MSG_GLOBAL_REQUEST:
msgGlobalRequest(msg, msglen);
break;
case Packets.SSH_MSG_REQUEST_SUCCESS:
msgGlobalSuccess();
break;
case Packets.SSH_MSG_REQUEST_FAILURE:
msgGlobalFailure();
break;
default:
throw new IOException("Cannot handle unknown channel message " + (msg[0] & 0xff));
}
}
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* SFTP Attribute Bits for the "attrib-bits" and "attrib-bits-valid" fields
* of the SFTP ATTR data type.
* <p>
* Yes, these are the "attrib-bits", even though they have "_FLAGS_" in
* their name. Don't ask - I did not invent it.
* <p>
* "<i>These fields, taken together, reflect various attributes of the file
* or directory, on the server. Bits not set in 'attrib-bits-valid' MUST be
* ignored in the 'attrib-bits' field. This allows both the server and the
* client to communicate only the bits it knows about without inadvertently
* twiddling bits they don't understand.</i>"
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: AttribBits.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*
*/
public class AttribBits
{
/**
* Advisory, read-only bit. This bit is not part of the access
* control information on the file, but is rather an advisory field
* indicating that the file should not be written.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_READONLY = 0x00000001;
/**
* The file is part of the operating system.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_SYSTEM = 0x00000002;
/**
* File SHOULD NOT be shown to user unless specifically requested.
* For example, most UNIX systems SHOULD set this bit if the filename
* begins with a 'period'. This bit may be read-only (see section 5.4 of
* the SFTP standard draft). Most UNIX systems will not allow this to be
* changed.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_HIDDEN = 0x00000004;
/**
* This attribute applies only to directories. This attribute is
* always read-only, and cannot be modified. This attribute means
* that files and directory names in this directory should be compared
* without regard to case.
* <p>
* It is recommended that where possible, the server's filesystem be
* allowed to do comparisons. For example, if a client wished to prompt
* a user before overwriting a file, it should not compare the new name
* with the previously retrieved list of names in the directory. Rather,
* it should first try to create the new file by specifying
* SSH_FXF_CREATE_NEW flag. Then, if this fails and returns
* SSH_FX_FILE_ALREADY_EXISTS, it should prompt the user and then retry
* the create specifying SSH_FXF_CREATE_TRUNCATE.
* <p>
* Unless otherwise specified, filenames are assumed to be case sensitive.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_CASE_INSENSITIVE = 0x00000008;
/**
* The file should be included in backup / archive operations.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_ARCHIVE = 0x00000010;
/**
* The file is stored on disk using file-system level transparent
* encryption. This flag does not affect the file data on the wire
* (for either READ or WRITE requests.)
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_ENCRYPTED = 0x00000020;
/**
* The file is stored on disk using file-system level transparent
* compression. This flag does not affect the file data on the wire.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_COMPRESSED = 0x00000040;
/**
* The file is a sparse file; this means that file blocks that have
* not been explicitly written are not stored on disk. For example, if
* a client writes a buffer at 10 M from the beginning of the file,
* the blocks between the previous EOF marker and the 10 M offset would
* not consume physical disk space.
* <p>
* Some servers may store all files as sparse files, in which case
* this bit will be unconditionally set. Other servers may not have
* a mechanism for determining if the file is sparse, and so the file
* MAY be stored sparse even if this flag is not set.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_SPARSE = 0x00000080;
/**
* Opening the file without either the SSH_FXF_ACCESS_APPEND_DATA or
* the SSH_FXF_ACCESS_APPEND_DATA_ATOMIC flag (see section 8.1.1.3
* of the SFTP standard draft) MUST result in an
* SSH_FX_INVALID_PARAMETER error.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_APPEND_ONLY = 0x00000100;
/**
* The file cannot be deleted or renamed, no hard link can be created
* to this file, and no data can be written to the file.
* <p>
* This bit implies a stronger level of protection than
* SSH_FILEXFER_ATTR_FLAGS_READONLY, the file permission mask or ACLs.
* Typically even the superuser cannot write to immutable files, and
* only the superuser can set or remove the bit.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_IMMUTABLE = 0x00000200;
/**
* When the file is modified, the changes are written synchronously
* to the disk.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_SYNC = 0x00000400;
/**
* The server MAY include this bit in a directory listing or realpath
* response. It indicates there was a failure in the translation to UTF-8.
* If this flag is included, the server SHOULD also include the
* UNTRANSLATED_NAME attribute.
*/
public static final int SSH_FILEXFER_ATTR_FLAGS_TRANSLATION_ERR = 0x00000800;
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* Permissions for the 'permissions' field in the SFTP ATTRS data type.
* <p>
* "<i>The 'permissions' field contains a bit mask specifying file permissions.
* These permissions correspond to the st_mode field of the stat structure
* defined by POSIX [IEEE.1003-1.1996].</i>"
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: AttribPermissions.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*
*/
public class AttribPermissions
{
/* Octal values! */
public static final int S_IRUSR = 0400;
public static final int S_IWUSR = 0200;
public static final int S_IXUSR = 0100;
public static final int S_IRGRP = 0040;
public static final int S_IWGRP = 0020;
public static final int S_IXGRP = 0010;
public static final int S_IROTH = 0004;
public static final int S_IWOTH = 0002;
public static final int S_IXOTH = 0001;
public static final int S_ISUID = 04000;
public static final int S_ISGID = 02000;
public static final int S_ISVTX = 01000;
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* Attribute Flags. The 'valid-attribute-flags' field in
* the SFTP ATTRS data type specifies which of the fields are actually present.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: AttribFlags.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*
*/
public class AttribFlags
{
/**
* Indicates that the 'allocation-size' field is present.
*/
public static final int SSH_FILEXFER_ATTR_SIZE = 0x00000001;
/** Protocol version 6:
* 0x00000002 was used in a previous version of this protocol.
* It is now a reserved value and MUST NOT appear in the mask.
* Some future version of this protocol may reuse this value.
*/
public static final int SSH_FILEXFER_ATTR_V3_UIDGID = 0x00000002;
/**
* Indicates that the 'permissions' field is present.
*/
public static final int SSH_FILEXFER_ATTR_PERMISSIONS = 0x00000004;
/**
* Indicates that the 'atime' and 'mtime' field are present
* (protocol v3).
*/
public static final int SSH_FILEXFER_ATTR_V3_ACMODTIME = 0x00000008;
/**
* Indicates that the 'atime' field is present.
*/
public static final int SSH_FILEXFER_ATTR_ACCESSTIME = 0x00000008;
/**
* Indicates that the 'createtime' field is present.
*/
public static final int SSH_FILEXFER_ATTR_CREATETIME = 0x00000010;
/**
* Indicates that the 'mtime' field is present.
*/
public static final int SSH_FILEXFER_ATTR_MODIFYTIME = 0x00000020;
/**
* Indicates that the 'acl' field is present.
*/
public static final int SSH_FILEXFER_ATTR_ACL = 0x00000040;
/**
* Indicates that the 'owner' and 'group' fields are present.
*/
public static final int SSH_FILEXFER_ATTR_OWNERGROUP = 0x00000080;
/**
* Indicates that additionally to the 'atime', 'createtime',
* 'mtime' and 'ctime' fields (if present), there is also
* 'atime-nseconds', 'createtime-nseconds', 'mtime-nseconds'
* and 'ctime-nseconds'.
*/
public static final int SSH_FILEXFER_ATTR_SUBSECOND_TIMES = 0x00000100;
/**
* Indicates that the 'attrib-bits' and 'attrib-bits-valid'
* fields are present.
*/
public static final int SSH_FILEXFER_ATTR_BITS = 0x00000200;
/**
* Indicates that the 'allocation-size' field is present.
*/
public static final int SSH_FILEXFER_ATTR_ALLOCATION_SIZE = 0x00000400;
/**
* Indicates that the 'text-hint' field is present.
*/
public static final int SSH_FILEXFER_ATTR_TEXT_HINT = 0x00000800;
/**
* Indicates that the 'mime-type' field is present.
*/
public static final int SSH_FILEXFER_ATTR_MIME_TYPE = 0x00001000;
/**
* Indicates that the 'link-count' field is present.
*/
public static final int SSH_FILEXFER_ATTR_LINK_COUNT = 0x00002000;
/**
* Indicates that the 'untranslated-name' field is present.
*/
public static final int SSH_FILEXFER_ATTR_UNTRANSLATED_NAME = 0x00004000;
/**
* Indicates that the 'ctime' field is present.
*/
public static final int SSH_FILEXFER_ATTR_CTIME = 0x00008000;
/**
* Indicates that the 'extended-count' field (and probablby some
* 'extensions') is present.
*/
public static final int SSH_FILEXFER_ATTR_EXTENDED = 0x80000000;
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* Types for the 'type' field in the SFTP ATTRS data type.
* <p>
* "<i>On a POSIX system, these values would be derived from the mode field
* of the stat structure. SPECIAL should be used for files that are of
* a known type which cannot be expressed in the protocol. UNKNOWN
* should be used if the type is not known.</i>"
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: AttribTypes.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*
*/
public class AttribTypes
{
public static final int SSH_FILEXFER_TYPE_REGULAR = 1;
public static final int SSH_FILEXFER_TYPE_DIRECTORY = 2;
public static final int SSH_FILEXFER_TYPE_SYMLINK = 3;
public static final int SSH_FILEXFER_TYPE_SPECIAL = 4;
public static final int SSH_FILEXFER_TYPE_UNKNOWN = 5;
public static final int SSH_FILEXFER_TYPE_SOCKET = 6;
public static final int SSH_FILEXFER_TYPE_CHAR_DEVICE = 7;
public static final int SSH_FILEXFER_TYPE_BLOCK_DEVICE = 8;
public static final int SSH_FILEXFER_TYPE_FIFO = 9;
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* SFTP Error Codes
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: ErrorCodes.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*
*/
public class ErrorCodes
{
public static final int SSH_FX_OK = 0;
public static final int SSH_FX_EOF = 1;
public static final int SSH_FX_NO_SUCH_FILE = 2;
public static final int SSH_FX_PERMISSION_DENIED = 3;
public static final int SSH_FX_FAILURE = 4;
public static final int SSH_FX_BAD_MESSAGE = 5;
public static final int SSH_FX_NO_CONNECTION = 6;
public static final int SSH_FX_CONNECTION_LOST = 7;
public static final int SSH_FX_OP_UNSUPPORTED = 8;
public static final int SSH_FX_INVALID_HANDLE = 9;
public static final int SSH_FX_NO_SUCH_PATH = 10;
public static final int SSH_FX_FILE_ALREADY_EXISTS = 11;
public static final int SSH_FX_WRITE_PROTECT = 12;
public static final int SSH_FX_NO_MEDIA = 13;
public static final int SSH_FX_NO_SPACE_ON_FILESYSTEM = 14;
public static final int SSH_FX_QUOTA_EXCEEDED = 15;
public static final int SSH_FX_UNKNOWN_PRINCIPAL = 16;
public static final int SSH_FX_LOCK_CONFLICT = 17;
public static final int SSH_FX_DIR_NOT_EMPTY = 18;
public static final int SSH_FX_NOT_A_DIRECTORY = 19;
public static final int SSH_FX_INVALID_FILENAME = 20;
public static final int SSH_FX_LINK_LOOP = 21;
public static final int SSH_FX_CANNOT_DELETE = 22;
public static final int SSH_FX_INVALID_PARAMETER = 23;
public static final int SSH_FX_FILE_IS_A_DIRECTORY = 24;
public static final int SSH_FX_BYTE_RANGE_LOCK_CONFLICT = 25;
public static final int SSH_FX_BYTE_RANGE_LOCK_REFUSED = 26;
public static final int SSH_FX_DELETE_PENDING = 27;
public static final int SSH_FX_FILE_CORRUPT = 28;
public static final int SSH_FX_OWNER_INVALID = 29;
public static final int SSH_FX_GROUP_INVALID = 30;
public static final int SSH_FX_NO_MATCHING_BYTE_RANGE_LOCK = 31;
private static final String[][] messages = {
{ "SSH_FX_OK", "Indicates successful completion of the operation." },
{ "SSH_FX_EOF",
"An attempt to read past the end-of-file was made; or, there are no more directory entries to return." },
{ "SSH_FX_NO_SUCH_FILE", "A reference was made to a file which does not exist." },
{ "SSH_FX_PERMISSION_DENIED", "The user does not have sufficient permissions to perform the operation." },
{ "SSH_FX_FAILURE", "An error occurred, but no specific error code exists to describe the failure." },
{ "SSH_FX_BAD_MESSAGE", "A badly formatted packet or other SFTP protocol incompatibility was detected." },
{ "SSH_FX_NO_CONNECTION", "There is no connection to the server." },
{ "SSH_FX_CONNECTION_LOST", "The connection to the server was lost." },
{ "SSH_FX_OP_UNSUPPORTED",
"An attempted operation could not be completed by the server because the server does not support the operation." },
{ "SSH_FX_INVALID_HANDLE", "The handle value was invalid." },
{ "SSH_FX_NO_SUCH_PATH", "The file path does not exist or is invalid." },
{ "SSH_FX_FILE_ALREADY_EXISTS", "The file already exists." },
{ "SSH_FX_WRITE_PROTECT", "The file is on read-only media, or the media is write protected." },
{ "SSH_FX_NO_MEDIA",
"The requested operation cannot be completed because there is no media available in the drive." },
{ "SSH_FX_NO_SPACE_ON_FILESYSTEM",
"The requested operation cannot be completed because there is insufficient free space on the filesystem." },
{ "SSH_FX_QUOTA_EXCEEDED",
"The operation cannot be completed because it would exceed the user's storage quota." },
{
"SSH_FX_UNKNOWN_PRINCIPAL",
"A principal referenced by the request (either the 'owner', 'group', or 'who' field of an ACL), was unknown. The error specific data contains the problematic names." },
{ "SSH_FX_LOCK_CONFLICT", "The file could not be opened because it is locked by another process." },
{ "SSH_FX_DIR_NOT_EMPTY", "The directory is not empty." },
{ "SSH_FX_NOT_A_DIRECTORY", "The specified file is not a directory." },
{ "SSH_FX_INVALID_FILENAME", "The filename is not valid." },
{ "SSH_FX_LINK_LOOP",
"Too many symbolic links encountered or, an SSH_FXF_NOFOLLOW open encountered a symbolic link as the final component." },
{ "SSH_FX_CANNOT_DELETE",
"The file cannot be deleted. One possible reason is that the advisory READONLY attribute-bit is set." },
{ "SSH_FX_INVALID_PARAMETER",
"One of the parameters was out of range, or the parameters specified cannot be used together." },
{ "SSH_FX_FILE_IS_A_DIRECTORY",
"The specified file was a directory in a context where a directory cannot be used." },
{ "SSH_FX_BYTE_RANGE_LOCK_CONFLICT",
" A read or write operation failed because another process's mandatory byte-range lock overlaps with the request." },
{ "SSH_FX_BYTE_RANGE_LOCK_REFUSED", "A request for a byte range lock was refused." },
{ "SSH_FX_DELETE_PENDING", "An operation was attempted on a file for which a delete operation is pending." },
{ "SSH_FX_FILE_CORRUPT", "The file is corrupt; an filesystem integrity check should be run." },
{ "SSH_FX_OWNER_INVALID", "The principal specified can not be assigned as an owner of a file." },
{ "SSH_FX_GROUP_INVALID", "The principal specified can not be assigned as the primary group of a file." },
{ "SSH_FX_NO_MATCHING_BYTE_RANGE_LOCK",
"The requested operation could not be completed because the specifed byte range lock has not been granted." },
};
public static final String[] getDescription(int errorCode)
{
if ((errorCode < 0) || (errorCode >= messages.length))
return null;
return messages[errorCode];
}
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* SFTP Paket Types
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: Packet.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*
*/
public class Packet
{
public static final int SSH_FXP_INIT = 1;
public static final int SSH_FXP_VERSION = 2;
public static final int SSH_FXP_OPEN = 3;
public static final int SSH_FXP_CLOSE = 4;
public static final int SSH_FXP_READ = 5;
public static final int SSH_FXP_WRITE = 6;
public static final int SSH_FXP_LSTAT = 7;
public static final int SSH_FXP_FSTAT = 8;
public static final int SSH_FXP_SETSTAT = 9;
public static final int SSH_FXP_FSETSTAT = 10;
public static final int SSH_FXP_OPENDIR = 11;
public static final int SSH_FXP_READDIR = 12;
public static final int SSH_FXP_REMOVE = 13;
public static final int SSH_FXP_MKDIR = 14;
public static final int SSH_FXP_RMDIR = 15;
public static final int SSH_FXP_REALPATH = 16;
public static final int SSH_FXP_STAT = 17;
public static final int SSH_FXP_RENAME = 18;
public static final int SSH_FXP_READLINK = 19;
public static final int SSH_FXP_SYMLINK = 20;
public static final int SSH_FXP_STATUS = 101;
public static final int SSH_FXP_HANDLE = 102;
public static final int SSH_FXP_DATA = 103;
public static final int SSH_FXP_NAME = 104;
public static final int SSH_FXP_ATTRS = 105;
public static final int SSH_FXP_EXTENDED = 200;
public static final int SSH_FXP_EXTENDED_REPLY = 201;
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* Values for the 'text-hint' field in the SFTP ATTRS data type.
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: AttrTextHints.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*
*/
public class AttrTextHints
{
/**
* The server knows the file is a text file, and should be opened
* using the SSH_FXF_ACCESS_TEXT_MODE flag.
*/
public static final int SSH_FILEXFER_ATTR_KNOWN_TEXT = 0x00;
/**
* The server has applied a heuristic or other mechanism and
* believes that the file should be opened with the
* SSH_FXF_ACCESS_TEXT_MODE flag.
*/
public static final int SSH_FILEXFER_ATTR_GUESSED_TEXT = 0x01;
/**
* The server knows the file has binary content.
*/
public static final int SSH_FILEXFER_ATTR_KNOWN_BINARY = 0x02;
/**
* The server has applied a heuristic or other mechanism and
* believes has binary content, and should not be opened with the
* SSH_FXF_ACCESS_TEXT_MODE flag.
*/
public static final int SSH_FILEXFER_ATTR_GUESSED_BINARY = 0x03;
}
| Java |
package com.trilead.ssh2.sftp;
/**
*
* SFTP Open Flags.
*
* The following table is provided to assist in mapping POSIX semantics
* to equivalent SFTP file open parameters:
* <p>
* TODO: This comment should be moved to the open method.
* <p>
* <ul>
* <li>O_RDONLY
* <ul><li>desired-access = READ_DATA | READ_ATTRIBUTES</li></ul>
* </li>
* </ul>
* <ul>
* <li>O_WRONLY
* <ul><li>desired-access = WRITE_DATA | WRITE_ATTRIBUTES</li></ul>
* </li>
* </ul>
* <ul>
* <li>O_RDWR
* <ul><li>desired-access = READ_DATA | READ_ATTRIBUTES | WRITE_DATA | WRITE_ATTRIBUTES</li></ul>
* </li>
* </ul>
* <ul>
* <li>O_APPEND
* <ul>
* <li>desired-access = WRITE_DATA | WRITE_ATTRIBUTES | APPEND_DATA</li>
* <li>flags = SSH_FXF_ACCESS_APPEND_DATA and or SSH_FXF_ACCESS_APPEND_DATA_ATOMIC</li>
* </ul>
* </li>
* </ul>
* <ul>
* <li>O_CREAT
* <ul>
* <li>flags = SSH_FXF_OPEN_OR_CREATE</li>
* </ul>
* </li>
* </ul>
* <ul>
* <li>O_TRUNC
* <ul>
* <li>flags = SSH_FXF_TRUNCATE_EXISTING</li>
* </ul>
* </li>
* </ul>
* <ul>
* <li>O_TRUNC|O_CREATE
* <ul>
* <li>flags = SSH_FXF_CREATE_TRUNCATE</li>
* </ul>
* </li>
* </ul>
*
* @author Christian Plattner, plattner@trilead.com
* @version $Id: OpenFlags.java,v 1.1 2007/10/15 12:49:55 cplattne Exp $
*/
public class OpenFlags
{
/**
* Disposition is a 3 bit field that controls how the file is opened.
* The server MUST support these bits (possible enumaration values:
* SSH_FXF_CREATE_NEW, SSH_FXF_CREATE_TRUNCATE, SSH_FXF_OPEN_EXISTING,
* SSH_FXF_OPEN_OR_CREATE or SSH_FXF_TRUNCATE_EXISTING).
*/
public static final int SSH_FXF_ACCESS_DISPOSITION = 0x00000007;
/**
* A new file is created; if the file already exists, the server
* MUST return status SSH_FX_FILE_ALREADY_EXISTS.
*/
public static final int SSH_FXF_CREATE_NEW = 0x00000000;
/**
* A new file is created; if the file already exists, it is opened
* and truncated.
*/
public static final int SSH_FXF_CREATE_TRUNCATE = 0x00000001;
/**
* An existing file is opened. If the file does not exist, the
* server MUST return SSH_FX_NO_SUCH_FILE. If a directory in the
* path does not exist, the server SHOULD return
* SSH_FX_NO_SUCH_PATH. It is also acceptable if the server
* returns SSH_FX_NO_SUCH_FILE in this case.
*/
public static final int SSH_FXF_OPEN_EXISTING = 0x00000002;
/**
* If the file exists, it is opened. If the file does not exist,
* it is created.
*/
public static final int SSH_FXF_OPEN_OR_CREATE = 0x00000003;
/**
* An existing file is opened and truncated. If the file does not
* exist, the server MUST return the same error codes as defined
* for SSH_FXF_OPEN_EXISTING.
*/
public static final int SSH_FXF_TRUNCATE_EXISTING = 0x00000004;
/**
* Data is always written at the end of the file. The offset field
* of the SSH_FXP_WRITE requests are ignored.
* <p>
* Data is not required to be appended atomically. This means that
* if multiple writers attempt to append data simultaneously, data
* from the first may be lost. However, data MAY be appended
* atomically.
*/
public static final int SSH_FXF_ACCESS_APPEND_DATA = 0x00000008;
/**
* Data is always written at the end of the file. The offset field
* of the SSH_FXP_WRITE requests are ignored.
* <p>
* Data MUST be written atomically so that there is no chance that
* multiple appenders can collide and result in data being lost.
* <p>
* If both append flags are specified, the server SHOULD use atomic
* append if it is available, but SHOULD use non-atomic appends
* otherwise. The server SHOULD NOT fail the request in this case.
*/
public static final int SSH_FXF_ACCESS_APPEND_DATA_ATOMIC = 0x00000010;
/**
* Indicates that the server should treat the file as text and
* convert it to the canonical newline convention in use.
* (See Determining Server Newline Convention in section 5.3 in the
* SFTP standard draft).
* <p>
* When a file is opened with this flag, the offset field in the read
* and write functions is ignored.
* <p>
* Servers MUST process multiple, parallel reads and writes correctly
* in this mode. Naturally, it is permissible for them to do this by
* serializing the requests.
* <p>
* Clients SHOULD use the SSH_FXF_ACCESS_APPEND_DATA flag to append
* data to a text file rather then using write with a calculated offset.
*/
public static final int SSH_FXF_ACCESS_TEXT_MODE = 0x00000020;
/**
* The server MUST guarantee that no other handle has been opened
* with ACE4_READ_DATA access, and that no other handle will be
* opened with ACE4_READ_DATA access until the client closes the
* handle. (This MUST apply both to other clients and to other
* processes on the server.)
* <p>
* If there is a conflicting lock the server MUST return
* SSH_FX_LOCK_CONFLICT. If the server cannot make the locking
* guarantee, it MUST return SSH_FX_OP_UNSUPPORTED.
* <p>
* Other handles MAY be opened for ACE4_WRITE_DATA or any other
* combination of accesses, as long as ACE4_READ_DATA is not included
* in the mask.
*/
public static final int SSH_FXF_ACCESS_BLOCK_READ = 0x00000040;
/**
* The server MUST guarantee that no other handle has been opened
* with ACE4_WRITE_DATA or ACE4_APPEND_DATA access, and that no other
* handle will be opened with ACE4_WRITE_DATA or ACE4_APPEND_DATA
* access until the client closes the handle. (This MUST apply both
* to other clients and to other processes on the server.)
* <p>
* If there is a conflicting lock the server MUST return
* SSH_FX_LOCK_CONFLICT. If the server cannot make the locking
* guarantee, it MUST return SSH_FX_OP_UNSUPPORTED.
* <p>
* Other handles MAY be opened for ACE4_READ_DATA or any other
* combination of accesses, as long as neither ACE4_WRITE_DATA nor
* ACE4_APPEND_DATA are included in the mask.
*/
public static final int SSH_FXF_ACCESS_BLOCK_WRITE = 0x00000080;
/**
* The server MUST guarantee that no other handle has been opened
* with ACE4_DELETE access, opened with the
* SSH_FXF_ACCESS_DELETE_ON_CLOSE flag set, and that no other handle
* will be opened with ACE4_DELETE access or with the
* SSH_FXF_ACCESS_DELETE_ON_CLOSE flag set, and that the file itself
* is not deleted in any other way until the client closes the handle.
* <p>
* If there is a conflicting lock the server MUST return
* SSH_FX_LOCK_CONFLICT. If the server cannot make the locking
* guarantee, it MUST return SSH_FX_OP_UNSUPPORTED.
*/
public static final int SSH_FXF_ACCESS_BLOCK_DELETE = 0x00000100;
/**
* If this bit is set, the above BLOCK modes are advisory. In advisory
* mode, only other accesses that specify a BLOCK mode need be
* considered when determining whether the BLOCK can be granted,
* and the server need not prevent I/O operations that violate the
* block mode.
* <p>
* The server MAY perform mandatory locking even if the BLOCK_ADVISORY
* bit is set.
*/
public static final int SSH_FXF_ACCESS_BLOCK_ADVISORY = 0x00000200;
/**
* If the final component of the path is a symlink, then the open
* MUST fail, and the error SSH_FX_LINK_LOOP MUST be returned.
*/
public static final int SSH_FXF_ACCESS_NOFOLLOW = 0x00000400;
/**
* The file should be deleted when the last handle to it is closed.
* (The last handle may not be an sftp-handle.) This MAY be emulated
* by a server if the OS doesn't support it by deleting the file when
* this handle is closed.
* <p>
* It is implementation specific whether the directory entry is
* removed immediately or when the handle is closed.
*/
public static final int SSH_FXF_ACCESS_DELETE_ON_CLOSE = 0x00000800;
}
| Java |
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/*
Copyright (c) 2001 Lapo Luchini.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS
OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
import java.io.*;
public class ZInputStream extends FilterInputStream {
protected ZStream z=new ZStream();
protected int bufsize=512;
protected int flush=JZlib.Z_NO_FLUSH;
protected byte[] buf=new byte[bufsize],
buf1=new byte[1];
protected boolean compress;
protected InputStream in=null;
public ZInputStream(InputStream in) {
this(in, false);
}
public ZInputStream(InputStream in, boolean nowrap) {
super(in);
this.in=in;
z.inflateInit(nowrap);
compress=false;
z.next_in=buf;
z.next_in_index=0;
z.avail_in=0;
}
public ZInputStream(InputStream in, int level) {
super(in);
this.in=in;
z.deflateInit(level);
compress=true;
z.next_in=buf;
z.next_in_index=0;
z.avail_in=0;
}
/*public int available() throws IOException {
return inf.finished() ? 0 : 1;
}*/
public int read() throws IOException {
if(read(buf1, 0, 1)==-1)
return(-1);
return(buf1[0]&0xFF);
}
private boolean nomoreinput=false;
public int read(byte[] b, int off, int len) throws IOException {
if(len==0)
return(0);
int err;
z.next_out=b;
z.next_out_index=off;
z.avail_out=len;
do {
if((z.avail_in==0)&&(!nomoreinput)) { // if buffer is empty and more input is avaiable, refill it
z.next_in_index=0;
z.avail_in=in.read(buf, 0, bufsize);//(bufsize<z.avail_out ? bufsize : z.avail_out));
if(z.avail_in==-1) {
z.avail_in=0;
nomoreinput=true;
}
}
if(compress)
err=z.deflate(flush);
else
err=z.inflate(flush);
if(nomoreinput&&(err==JZlib.Z_BUF_ERROR))
return(-1);
if(err!=JZlib.Z_OK && err!=JZlib.Z_STREAM_END)
throw new ZStreamException((compress ? "de" : "in")+"flating: "+z.msg);
if((nomoreinput||err==JZlib.Z_STREAM_END)&&(z.avail_out==len))
return(-1);
}
while(z.avail_out==len&&err==JZlib.Z_OK);
//System.err.print("("+(len-z.avail_out)+")");
return(len-z.avail_out);
}
public long skip(long n) throws IOException {
int len=512;
if(n<len)
len=(int)n;
byte[] tmp=new byte[len];
return((long)read(tmp));
}
public int getFlushMode() {
return(flush);
}
public void setFlushMode(int flush) {
this.flush=flush;
}
/**
* Returns the total number of bytes input so far.
*/
public long getTotalIn() {
return z.total_in;
}
/**
* Returns the total number of bytes output so far.
*/
public long getTotalOut() {
return z.total_out;
}
public void close() throws IOException{
in.close();
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/*
Copyright (c) 2001 Lapo Luchini.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS
OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
import java.io.*;
public class ZOutputStream extends OutputStream {
protected ZStream z=new ZStream();
protected int bufsize=512;
protected int flush=JZlib.Z_NO_FLUSH;
protected byte[] buf=new byte[bufsize],
buf1=new byte[1];
protected boolean compress;
protected OutputStream out;
public ZOutputStream(OutputStream out) {
super();
this.out=out;
z.inflateInit();
compress=false;
}
public ZOutputStream(OutputStream out, int level) {
this(out, level, false);
}
public ZOutputStream(OutputStream out, int level, boolean nowrap) {
super();
this.out=out;
z.deflateInit(level, nowrap);
compress=true;
}
public void write(int b) throws IOException {
buf1[0]=(byte)b;
write(buf1, 0, 1);
}
public void write(byte b[], int off, int len) throws IOException {
if(len==0)
return;
int err;
z.next_in=b;
z.next_in_index=off;
z.avail_in=len;
do{
z.next_out=buf;
z.next_out_index=0;
z.avail_out=bufsize;
if(compress)
err=z.deflate(flush);
else
err=z.inflate(flush);
if(err!=JZlib.Z_OK)
throw new ZStreamException((compress?"de":"in")+"flating: "+z.msg);
out.write(buf, 0, bufsize-z.avail_out);
}
while(z.avail_in>0 || z.avail_out==0);
}
public int getFlushMode() {
return(flush);
}
public void setFlushMode(int flush) {
this.flush=flush;
}
public void finish() throws IOException {
int err;
do{
z.next_out=buf;
z.next_out_index=0;
z.avail_out=bufsize;
if(compress){ err=z.deflate(JZlib.Z_FINISH); }
else{ err=z.inflate(JZlib.Z_FINISH); }
if(err!=JZlib.Z_STREAM_END && err != JZlib.Z_OK)
throw new ZStreamException((compress?"de":"in")+"flating: "+z.msg);
if(bufsize-z.avail_out>0){
out.write(buf, 0, bufsize-z.avail_out);
}
}
while(z.avail_in>0 || z.avail_out==0);
flush();
}
public void end() {
if(z==null)
return;
if(compress){ z.deflateEnd(); }
else{ z.inflateEnd(); }
z.free();
z=null;
}
public void close() throws IOException {
try{
try{finish();}
catch (IOException ignored) {}
}
finally{
end();
out.close();
out=null;
}
}
/**
* Returns the total number of bytes input so far.
*/
public long getTotalIn() {
return z.total_in;
}
/**
* Returns the total number of bytes output so far.
*/
public long getTotalOut() {
return z.total_out;
}
public void flush() throws IOException {
out.flush();
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final public class JZlib{
private static final String version="1.0.2";
public static String version(){return version;}
// compression levels
static final public int Z_NO_COMPRESSION=0;
static final public int Z_BEST_SPEED=1;
static final public int Z_BEST_COMPRESSION=9;
static final public int Z_DEFAULT_COMPRESSION=(-1);
// compression strategy
static final public int Z_FILTERED=1;
static final public int Z_HUFFMAN_ONLY=2;
static final public int Z_DEFAULT_STRATEGY=0;
static final public int Z_NO_FLUSH=0;
static final public int Z_PARTIAL_FLUSH=1;
static final public int Z_SYNC_FLUSH=2;
static final public int Z_FULL_FLUSH=3;
static final public int Z_FINISH=4;
static final public int Z_OK=0;
static final public int Z_STREAM_END=1;
static final public int Z_NEED_DICT=2;
static final public int Z_ERRNO=-1;
static final public int Z_STREAM_ERROR=-2;
static final public int Z_DATA_ERROR=-3;
static final public int Z_MEM_ERROR=-4;
static final public int Z_BUF_ERROR=-5;
static final public int Z_VERSION_ERROR=-6;
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
public class ZStreamException extends java.io.IOException {
public ZStreamException() {
super();
}
public ZStreamException(String s) {
super(s);
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final class InfCodes{
static final private int[] inflate_mask = {
0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
0x00007fff, 0x0000ffff
};
static final private int Z_OK=0;
static final private int Z_STREAM_END=1;
static final private int Z_NEED_DICT=2;
static final private int Z_ERRNO=-1;
static final private int Z_STREAM_ERROR=-2;
static final private int Z_DATA_ERROR=-3;
static final private int Z_MEM_ERROR=-4;
static final private int Z_BUF_ERROR=-5;
static final private int Z_VERSION_ERROR=-6;
// waiting for "i:"=input,
// "o:"=output,
// "x:"=nothing
static final private int START=0; // x: set up for LEN
static final private int LEN=1; // i: get length/literal/eob next
static final private int LENEXT=2; // i: getting length extra (have base)
static final private int DIST=3; // i: get distance next
static final private int DISTEXT=4;// i: getting distance extra
static final private int COPY=5; // o: copying bytes in window, waiting for space
static final private int LIT=6; // o: got literal, waiting for output space
static final private int WASH=7; // o: got eob, possibly still output waiting
static final private int END=8; // x: got eob and all data flushed
static final private int BADCODE=9;// x: got error
int mode; // current inflate_codes mode
// mode dependent information
int len;
int[] tree; // pointer into tree
int tree_index=0;
int need; // bits needed
int lit;
// if EXT or COPY, where and how much
int get; // bits to get for extra
int dist; // distance back to copy from
byte lbits; // ltree bits decoded per branch
byte dbits; // dtree bits decoder per branch
int[] ltree; // literal/length/eob tree
int ltree_index; // literal/length/eob tree
int[] dtree; // distance tree
int dtree_index; // distance tree
InfCodes(){
}
void init(int bl, int bd,
int[] tl, int tl_index,
int[] td, int td_index, ZStream z){
mode=START;
lbits=(byte)bl;
dbits=(byte)bd;
ltree=tl;
ltree_index=tl_index;
dtree = td;
dtree_index=td_index;
tree=null;
}
int proc(InfBlocks s, ZStream z, int r){
int j; // temporary storage
int[] t; // temporary pointer
int tindex; // temporary pointer
int e; // extra bits or operation
int b=0; // bit buffer
int k=0; // bits in bit buffer
int p=0; // input data pointer
int n; // bytes available there
int q; // output window write pointer
int m; // bytes to end of window or read pointer
int f; // pointer to copy strings from
// copy input/output information to locals (UPDATE macro restores)
p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
// process input and output based on current state
while (true){
switch (mode){
// waiting for "i:"=input, "o:"=output, "x:"=nothing
case START: // x: set up for LEN
if (m >= 258 && n >= 10){
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
r = inflate_fast(lbits, dbits,
ltree, ltree_index,
dtree, dtree_index,
s, z);
p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
if (r != Z_OK){
mode = r == Z_STREAM_END ? WASH : BADCODE;
break;
}
}
need = lbits;
tree = ltree;
tree_index=ltree_index;
mode = LEN;
case LEN: // i: get length/literal/eob next
j = need;
while(k<(j)){
if(n!=0)r=Z_OK;
else{
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
n--;
b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
tindex=(tree_index+(b&inflate_mask[j]))*3;
b>>>=(tree[tindex+1]);
k-=(tree[tindex+1]);
e=tree[tindex];
if(e == 0){ // literal
lit = tree[tindex+2];
mode = LIT;
break;
}
if((e & 16)!=0 ){ // length
get = e & 15;
len = tree[tindex+2];
mode = LENEXT;
break;
}
if ((e & 64) == 0){ // next table
need = e;
tree_index = tindex/3+tree[tindex+2];
break;
}
if ((e & 32)!=0){ // end of block
mode = WASH;
break;
}
mode = BADCODE; // invalid code
z.msg = "invalid literal/length code";
r = Z_DATA_ERROR;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
case LENEXT: // i: getting length extra (have base)
j = get;
while(k<(j)){
if(n!=0)r=Z_OK;
else{
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
n--; b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
len += (b & inflate_mask[j]);
b>>=j;
k-=j;
need = dbits;
tree = dtree;
tree_index=dtree_index;
mode = DIST;
case DIST: // i: get distance next
j = need;
while(k<(j)){
if(n!=0)r=Z_OK;
else{
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
n--; b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
tindex=(tree_index+(b & inflate_mask[j]))*3;
b>>=tree[tindex+1];
k-=tree[tindex+1];
e = (tree[tindex]);
if((e & 16)!=0){ // distance
get = e & 15;
dist = tree[tindex+2];
mode = DISTEXT;
break;
}
if ((e & 64) == 0){ // next table
need = e;
tree_index = tindex/3 + tree[tindex+2];
break;
}
mode = BADCODE; // invalid code
z.msg = "invalid distance code";
r = Z_DATA_ERROR;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
case DISTEXT: // i: getting distance extra
j = get;
while(k<(j)){
if(n!=0)r=Z_OK;
else{
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
n--; b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
dist += (b & inflate_mask[j]);
b>>=j;
k-=j;
mode = COPY;
case COPY: // o: copying bytes in window, waiting for space
f = q - dist;
while(f < 0){ // modulo window size-"while" instead
f += s.end; // of "if" handles invalid distances
}
while (len!=0){
if(m==0){
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
if(m==0){
s.write=q; r=s.inflate_flush(z,r);
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
if(m==0){
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
}
}
s.window[q++]=s.window[f++]; m--;
if (f == s.end)
f = 0;
len--;
}
mode = START;
break;
case LIT: // o: got literal, waiting for output space
if(m==0){
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
if(m==0){
s.write=q; r=s.inflate_flush(z,r);
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
if(m==0){
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
}
}
r=Z_OK;
s.window[q++]=(byte)lit; m--;
mode = START;
break;
case WASH: // o: got eob, possibly more output
if (k > 7){ // return unused byte, if any
k -= 8;
n++;
p--; // can always return one
}
s.write=q; r=s.inflate_flush(z,r);
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
if (s.read != s.write){
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
mode = END;
case END:
r = Z_STREAM_END;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
case BADCODE: // x: got error
r = Z_DATA_ERROR;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
default:
r = Z_STREAM_ERROR;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return s.inflate_flush(z,r);
}
}
}
void free(ZStream z){
// ZFREE(z, c);
}
// Called with number of bytes left to write in window at least 258
// (the maximum string length) and number of input bytes available
// at least ten. The ten bytes are six bytes for the longest length/
// distance pair plus four bytes for overloading the bit buffer.
int inflate_fast(int bl, int bd,
int[] tl, int tl_index,
int[] td, int td_index,
InfBlocks s, ZStream z){
int t; // temporary pointer
int[] tp; // temporary pointer
int tp_index; // temporary pointer
int e; // extra bits or operation
int b; // bit buffer
int k; // bits in bit buffer
int p; // input data pointer
int n; // bytes available there
int q; // output window write pointer
int m; // bytes to end of window or read pointer
int ml; // mask for literal/length tree
int md; // mask for distance tree
int c; // bytes to copy
int d; // distance back to copy from
int r; // copy source pointer
int tp_index_t_3; // (tp_index+t)*3
// load input, output, bit values
p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
q=s.write;m=q<s.read?s.read-q-1:s.end-q;
// initialize masks
ml = inflate_mask[bl];
md = inflate_mask[bd];
// do until not enough input or output space for fast loop
do { // assume called with m >= 258 && n >= 10
// get literal/length code
while(k<(20)){ // max bits for literal/length code
n--;
b|=(z.next_in[p++]&0xff)<<k;k+=8;
}
t= b&ml;
tp=tl;
tp_index=tl_index;
tp_index_t_3=(tp_index+t)*3;
if ((e = tp[tp_index_t_3]) == 0){
b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
s.window[q++] = (byte)tp[tp_index_t_3+2];
m--;
continue;
}
do {
b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
if((e&16)!=0){
e &= 15;
c = tp[tp_index_t_3+2] + ((int)b & inflate_mask[e]);
b>>=e; k-=e;
// decode distance base of block to copy
while(k<(15)){ // max bits for distance code
n--;
b|=(z.next_in[p++]&0xff)<<k;k+=8;
}
t= b&md;
tp=td;
tp_index=td_index;
tp_index_t_3=(tp_index+t)*3;
e = tp[tp_index_t_3];
do {
b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
if((e&16)!=0){
// get extra bits to add to distance base
e &= 15;
while(k<(e)){ // get extra bits (up to 13)
n--;
b|=(z.next_in[p++]&0xff)<<k;k+=8;
}
d = tp[tp_index_t_3+2] + (b&inflate_mask[e]);
b>>=(e); k-=(e);
// do the copy
m -= c;
if (q >= d){ // offset before dest
// just copy
r=q-d;
if(q-r>0 && 2>(q-r)){
s.window[q++]=s.window[r++]; // minimum count is three,
s.window[q++]=s.window[r++]; // so unroll loop a little
c-=2;
}
else{
System.arraycopy(s.window, r, s.window, q, 2);
q+=2; r+=2; c-=2;
}
}
else{ // else offset after destination
r=q-d;
do{
r+=s.end; // force pointer in window
}while(r<0); // covers invalid distances
e=s.end-r;
if(c>e){ // if source crosses,
c-=e; // wrapped copy
if(q-r>0 && e>(q-r)){
do{s.window[q++] = s.window[r++];}
while(--e!=0);
}
else{
System.arraycopy(s.window, r, s.window, q, e);
q+=e; r+=e; e=0;
}
r = 0; // copy rest from start of window
}
}
// copy all or what's left
if(q-r>0 && c>(q-r)){
do{s.window[q++] = s.window[r++];}
while(--c!=0);
}
else{
System.arraycopy(s.window, r, s.window, q, c);
q+=c; r+=c; c=0;
}
break;
}
else if((e&64)==0){
t+=tp[tp_index_t_3+2];
t+=(b&inflate_mask[e]);
tp_index_t_3=(tp_index+t)*3;
e=tp[tp_index_t_3];
}
else{
z.msg = "invalid distance code";
c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return Z_DATA_ERROR;
}
}
while(true);
break;
}
if((e&64)==0){
t+=tp[tp_index_t_3+2];
t+=(b&inflate_mask[e]);
tp_index_t_3=(tp_index+t)*3;
if((e=tp[tp_index_t_3])==0){
b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
s.window[q++]=(byte)tp[tp_index_t_3+2];
m--;
break;
}
}
else if((e&32)!=0){
c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return Z_STREAM_END;
}
else{
z.msg="invalid literal/length code";
c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return Z_DATA_ERROR;
}
}
while(true);
}
while(m>=258 && n>= 10);
// not enough input or output--restore pointers and return
c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
s.bitb=b;s.bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
s.write=q;
return Z_OK;
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final class InfTree{
static final private int MANY=1440;
static final private int Z_OK=0;
static final private int Z_STREAM_END=1;
static final private int Z_NEED_DICT=2;
static final private int Z_ERRNO=-1;
static final private int Z_STREAM_ERROR=-2;
static final private int Z_DATA_ERROR=-3;
static final private int Z_MEM_ERROR=-4;
static final private int Z_BUF_ERROR=-5;
static final private int Z_VERSION_ERROR=-6;
static final int fixed_bl = 9;
static final int fixed_bd = 5;
static final int[] fixed_tl = {
96,7,256, 0,8,80, 0,8,16, 84,8,115,
82,7,31, 0,8,112, 0,8,48, 0,9,192,
80,7,10, 0,8,96, 0,8,32, 0,9,160,
0,8,0, 0,8,128, 0,8,64, 0,9,224,
80,7,6, 0,8,88, 0,8,24, 0,9,144,
83,7,59, 0,8,120, 0,8,56, 0,9,208,
81,7,17, 0,8,104, 0,8,40, 0,9,176,
0,8,8, 0,8,136, 0,8,72, 0,9,240,
80,7,4, 0,8,84, 0,8,20, 85,8,227,
83,7,43, 0,8,116, 0,8,52, 0,9,200,
81,7,13, 0,8,100, 0,8,36, 0,9,168,
0,8,4, 0,8,132, 0,8,68, 0,9,232,
80,7,8, 0,8,92, 0,8,28, 0,9,152,
84,7,83, 0,8,124, 0,8,60, 0,9,216,
82,7,23, 0,8,108, 0,8,44, 0,9,184,
0,8,12, 0,8,140, 0,8,76, 0,9,248,
80,7,3, 0,8,82, 0,8,18, 85,8,163,
83,7,35, 0,8,114, 0,8,50, 0,9,196,
81,7,11, 0,8,98, 0,8,34, 0,9,164,
0,8,2, 0,8,130, 0,8,66, 0,9,228,
80,7,7, 0,8,90, 0,8,26, 0,9,148,
84,7,67, 0,8,122, 0,8,58, 0,9,212,
82,7,19, 0,8,106, 0,8,42, 0,9,180,
0,8,10, 0,8,138, 0,8,74, 0,9,244,
80,7,5, 0,8,86, 0,8,22, 192,8,0,
83,7,51, 0,8,118, 0,8,54, 0,9,204,
81,7,15, 0,8,102, 0,8,38, 0,9,172,
0,8,6, 0,8,134, 0,8,70, 0,9,236,
80,7,9, 0,8,94, 0,8,30, 0,9,156,
84,7,99, 0,8,126, 0,8,62, 0,9,220,
82,7,27, 0,8,110, 0,8,46, 0,9,188,
0,8,14, 0,8,142, 0,8,78, 0,9,252,
96,7,256, 0,8,81, 0,8,17, 85,8,131,
82,7,31, 0,8,113, 0,8,49, 0,9,194,
80,7,10, 0,8,97, 0,8,33, 0,9,162,
0,8,1, 0,8,129, 0,8,65, 0,9,226,
80,7,6, 0,8,89, 0,8,25, 0,9,146,
83,7,59, 0,8,121, 0,8,57, 0,9,210,
81,7,17, 0,8,105, 0,8,41, 0,9,178,
0,8,9, 0,8,137, 0,8,73, 0,9,242,
80,7,4, 0,8,85, 0,8,21, 80,8,258,
83,7,43, 0,8,117, 0,8,53, 0,9,202,
81,7,13, 0,8,101, 0,8,37, 0,9,170,
0,8,5, 0,8,133, 0,8,69, 0,9,234,
80,7,8, 0,8,93, 0,8,29, 0,9,154,
84,7,83, 0,8,125, 0,8,61, 0,9,218,
82,7,23, 0,8,109, 0,8,45, 0,9,186,
0,8,13, 0,8,141, 0,8,77, 0,9,250,
80,7,3, 0,8,83, 0,8,19, 85,8,195,
83,7,35, 0,8,115, 0,8,51, 0,9,198,
81,7,11, 0,8,99, 0,8,35, 0,9,166,
0,8,3, 0,8,131, 0,8,67, 0,9,230,
80,7,7, 0,8,91, 0,8,27, 0,9,150,
84,7,67, 0,8,123, 0,8,59, 0,9,214,
82,7,19, 0,8,107, 0,8,43, 0,9,182,
0,8,11, 0,8,139, 0,8,75, 0,9,246,
80,7,5, 0,8,87, 0,8,23, 192,8,0,
83,7,51, 0,8,119, 0,8,55, 0,9,206,
81,7,15, 0,8,103, 0,8,39, 0,9,174,
0,8,7, 0,8,135, 0,8,71, 0,9,238,
80,7,9, 0,8,95, 0,8,31, 0,9,158,
84,7,99, 0,8,127, 0,8,63, 0,9,222,
82,7,27, 0,8,111, 0,8,47, 0,9,190,
0,8,15, 0,8,143, 0,8,79, 0,9,254,
96,7,256, 0,8,80, 0,8,16, 84,8,115,
82,7,31, 0,8,112, 0,8,48, 0,9,193,
80,7,10, 0,8,96, 0,8,32, 0,9,161,
0,8,0, 0,8,128, 0,8,64, 0,9,225,
80,7,6, 0,8,88, 0,8,24, 0,9,145,
83,7,59, 0,8,120, 0,8,56, 0,9,209,
81,7,17, 0,8,104, 0,8,40, 0,9,177,
0,8,8, 0,8,136, 0,8,72, 0,9,241,
80,7,4, 0,8,84, 0,8,20, 85,8,227,
83,7,43, 0,8,116, 0,8,52, 0,9,201,
81,7,13, 0,8,100, 0,8,36, 0,9,169,
0,8,4, 0,8,132, 0,8,68, 0,9,233,
80,7,8, 0,8,92, 0,8,28, 0,9,153,
84,7,83, 0,8,124, 0,8,60, 0,9,217,
82,7,23, 0,8,108, 0,8,44, 0,9,185,
0,8,12, 0,8,140, 0,8,76, 0,9,249,
80,7,3, 0,8,82, 0,8,18, 85,8,163,
83,7,35, 0,8,114, 0,8,50, 0,9,197,
81,7,11, 0,8,98, 0,8,34, 0,9,165,
0,8,2, 0,8,130, 0,8,66, 0,9,229,
80,7,7, 0,8,90, 0,8,26, 0,9,149,
84,7,67, 0,8,122, 0,8,58, 0,9,213,
82,7,19, 0,8,106, 0,8,42, 0,9,181,
0,8,10, 0,8,138, 0,8,74, 0,9,245,
80,7,5, 0,8,86, 0,8,22, 192,8,0,
83,7,51, 0,8,118, 0,8,54, 0,9,205,
81,7,15, 0,8,102, 0,8,38, 0,9,173,
0,8,6, 0,8,134, 0,8,70, 0,9,237,
80,7,9, 0,8,94, 0,8,30, 0,9,157,
84,7,99, 0,8,126, 0,8,62, 0,9,221,
82,7,27, 0,8,110, 0,8,46, 0,9,189,
0,8,14, 0,8,142, 0,8,78, 0,9,253,
96,7,256, 0,8,81, 0,8,17, 85,8,131,
82,7,31, 0,8,113, 0,8,49, 0,9,195,
80,7,10, 0,8,97, 0,8,33, 0,9,163,
0,8,1, 0,8,129, 0,8,65, 0,9,227,
80,7,6, 0,8,89, 0,8,25, 0,9,147,
83,7,59, 0,8,121, 0,8,57, 0,9,211,
81,7,17, 0,8,105, 0,8,41, 0,9,179,
0,8,9, 0,8,137, 0,8,73, 0,9,243,
80,7,4, 0,8,85, 0,8,21, 80,8,258,
83,7,43, 0,8,117, 0,8,53, 0,9,203,
81,7,13, 0,8,101, 0,8,37, 0,9,171,
0,8,5, 0,8,133, 0,8,69, 0,9,235,
80,7,8, 0,8,93, 0,8,29, 0,9,155,
84,7,83, 0,8,125, 0,8,61, 0,9,219,
82,7,23, 0,8,109, 0,8,45, 0,9,187,
0,8,13, 0,8,141, 0,8,77, 0,9,251,
80,7,3, 0,8,83, 0,8,19, 85,8,195,
83,7,35, 0,8,115, 0,8,51, 0,9,199,
81,7,11, 0,8,99, 0,8,35, 0,9,167,
0,8,3, 0,8,131, 0,8,67, 0,9,231,
80,7,7, 0,8,91, 0,8,27, 0,9,151,
84,7,67, 0,8,123, 0,8,59, 0,9,215,
82,7,19, 0,8,107, 0,8,43, 0,9,183,
0,8,11, 0,8,139, 0,8,75, 0,9,247,
80,7,5, 0,8,87, 0,8,23, 192,8,0,
83,7,51, 0,8,119, 0,8,55, 0,9,207,
81,7,15, 0,8,103, 0,8,39, 0,9,175,
0,8,7, 0,8,135, 0,8,71, 0,9,239,
80,7,9, 0,8,95, 0,8,31, 0,9,159,
84,7,99, 0,8,127, 0,8,63, 0,9,223,
82,7,27, 0,8,111, 0,8,47, 0,9,191,
0,8,15, 0,8,143, 0,8,79, 0,9,255
};
static final int[] fixed_td = {
80,5,1, 87,5,257, 83,5,17, 91,5,4097,
81,5,5, 89,5,1025, 85,5,65, 93,5,16385,
80,5,3, 88,5,513, 84,5,33, 92,5,8193,
82,5,9, 90,5,2049, 86,5,129, 192,5,24577,
80,5,2, 87,5,385, 83,5,25, 91,5,6145,
81,5,7, 89,5,1537, 85,5,97, 93,5,24577,
80,5,4, 88,5,769, 84,5,49, 92,5,12289,
82,5,13, 90,5,3073, 86,5,193, 192,5,24577
};
// Tables for deflate from PKZIP's appnote.txt.
static final int[] cplens = { // Copy lengths for literal codes 257..285
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
};
// see note #13 above about 258
static final int[] cplext = { // Extra bits for literal codes 257..285
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112 // 112==invalid
};
static final int[] cpdist = { // Copy offsets for distance codes 0..29
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
8193, 12289, 16385, 24577
};
static final int[] cpdext = { // Extra bits for distance codes
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
12, 12, 13, 13};
// If BMAX needs to be larger than 16, then h and x[] should be uLong.
static final int BMAX=15; // maximum bit length of any code
int[] hn = null; // hufts used in space
int[] v = null; // work area for huft_build
int[] c = null; // bit length count table
int[] r = null; // table entry for structure assignment
int[] u = null; // table stack
int[] x = null; // bit offsets, then code stack
private int huft_build(int[] b, // code lengths in bits (all assumed <= BMAX)
int bindex,
int n, // number of codes (assumed <= 288)
int s, // number of simple-valued codes (0..s-1)
int[] d, // list of base values for non-simple codes
int[] e, // list of extra bits for non-simple codes
int[] t, // result: starting table
int[] m, // maximum lookup bits, returns actual
int[] hp,// space for trees
int[] hn,// hufts used in space
int[] v // working area: values in order of bit length
){
// Given a list of code lengths and a maximum table size, make a set of
// tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
// if the given code set is incomplete (the tables are still built in this
// case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
// lengths), or Z_MEM_ERROR if not enough memory.
int a; // counter for codes of length k
int f; // i repeats in table every f entries
int g; // maximum code length
int h; // table level
int i; // counter, current code
int j; // counter
int k; // number of bits in current code
int l; // bits per table (returned in m)
int mask; // (1 << w) - 1, to avoid cc -O bug on HP
int p; // pointer into c[], b[], or v[]
int q; // points to current table
int w; // bits before this table == (l * h)
int xp; // pointer into x
int y; // number of dummy codes added
int z; // number of entries in current table
// Generate counts for each bit length
p = 0; i = n;
do {
c[b[bindex+p]]++; p++; i--; // assume all entries <= BMAX
}while(i!=0);
if(c[0] == n){ // null input--all zero length codes
t[0] = -1;
m[0] = 0;
return Z_OK;
}
// Find minimum and maximum length, bound *m by those
l = m[0];
for (j = 1; j <= BMAX; j++)
if(c[j]!=0) break;
k = j; // minimum code length
if(l < j){
l = j;
}
for (i = BMAX; i!=0; i--){
if(c[i]!=0) break;
}
g = i; // maximum code length
if(l > i){
l = i;
}
m[0] = l;
// Adjust last length count to fill out codes, if needed
for (y = 1 << j; j < i; j++, y <<= 1){
if ((y -= c[j]) < 0){
return Z_DATA_ERROR;
}
}
if ((y -= c[i]) < 0){
return Z_DATA_ERROR;
}
c[i] += y;
// Generate starting offsets into the value table for each length
x[1] = j = 0;
p = 1; xp = 2;
while (--i!=0) { // note that i == g from above
x[xp] = (j += c[p]);
xp++;
p++;
}
// Make a table of values in order of bit lengths
i = 0; p = 0;
do {
if ((j = b[bindex+p]) != 0){
v[x[j]++] = i;
}
p++;
}
while (++i < n);
n = x[g]; // set n to length of v
// Generate the Huffman codes and for each, make the table entries
x[0] = i = 0; // first Huffman code is zero
p = 0; // grab values in bit order
h = -1; // no tables yet--level -1
w = -l; // bits decoded == (l * h)
u[0] = 0; // just to keep compilers happy
q = 0; // ditto
z = 0; // ditto
// go through the bit lengths (k already is bits in shortest code)
for (; k <= g; k++){
a = c[k];
while (a--!=0){
// here i is the Huffman code of length k bits for value *p
// make tables up to required level
while (k > w + l){
h++;
w += l; // previous table always l bits
// compute minimum size table less than or equal to l bits
z = g - w;
z = (z > l) ? l : z; // table size upper limit
if((f=1<<(j=k-w))>a+1){ // try a k-w bit table
// too few codes for k-w bit table
f -= a + 1; // deduct codes from patterns left
xp = k;
if(j < z){
while (++j < z){ // try smaller tables up to z bits
if((f <<= 1) <= c[++xp])
break; // enough codes to use up j bits
f -= c[xp]; // else deduct codes from patterns
}
}
}
z = 1 << j; // table entries for j-bit table
// allocate new table
if (hn[0] + z > MANY){ // (note: doesn't matter for fixed)
return Z_DATA_ERROR; // overflow of MANY
}
u[h] = q = /*hp+*/ hn[0]; // DEBUG
hn[0] += z;
// connect to last table, if there is one
if(h!=0){
x[h]=i; // save pattern for backing up
r[0]=(byte)j; // bits in this table
r[1]=(byte)l; // bits to dump before this table
j=i>>>(w - l);
r[2] = (int)(q - u[h-1] - j); // offset to this table
System.arraycopy(r, 0, hp, (u[h-1]+j)*3, 3); // connect to last table
}
else{
t[0] = q; // first table is returned result
}
}
// set up table entry in r
r[1] = (byte)(k - w);
if (p >= n){
r[0] = 128 + 64; // out of values--invalid code
}
else if (v[p] < s){
r[0] = (byte)(v[p] < 256 ? 0 : 32 + 64); // 256 is end-of-block
r[2] = v[p++]; // simple code is just the value
}
else{
r[0]=(byte)(e[v[p]-s]+16+64); // non-simple--look up in lists
r[2]=d[v[p++] - s];
}
// fill code-like entries with r
f=1<<(k-w);
for (j=i>>>w;j<z;j+=f){
System.arraycopy(r, 0, hp, (q+j)*3, 3);
}
// backwards increment the k-bit code i
for (j = 1 << (k - 1); (i & j)!=0; j >>>= 1){
i ^= j;
}
i ^= j;
// backup over finished tables
mask = (1 << w) - 1; // needed on HP, cc -O bug
while ((i & mask) != x[h]){
h--; // don't need to update q
w -= l;
mask = (1 << w) - 1;
}
}
}
// Return Z_BUF_ERROR if we were given an incomplete table
return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
}
int inflate_trees_bits(int[] c, // 19 code lengths
int[] bb, // bits tree desired/actual depth
int[] tb, // bits tree result
int[] hp, // space for trees
ZStream z // for messages
){
int result;
initWorkArea(19);
hn[0]=0;
result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
if(result == Z_DATA_ERROR){
z.msg = "oversubscribed dynamic bit lengths tree";
}
else if(result == Z_BUF_ERROR || bb[0] == 0){
z.msg = "incomplete dynamic bit lengths tree";
result = Z_DATA_ERROR;
}
return result;
}
int inflate_trees_dynamic(int nl, // number of literal/length codes
int nd, // number of distance codes
int[] c, // that many (total) code lengths
int[] bl, // literal desired/actual bit depth
int[] bd, // distance desired/actual bit depth
int[] tl, // literal/length tree result
int[] td, // distance tree result
int[] hp, // space for trees
ZStream z // for messages
){
int result;
// build literal/length tree
initWorkArea(288);
hn[0]=0;
result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
if (result != Z_OK || bl[0] == 0){
if(result == Z_DATA_ERROR){
z.msg = "oversubscribed literal/length tree";
}
else if (result != Z_MEM_ERROR){
z.msg = "incomplete literal/length tree";
result = Z_DATA_ERROR;
}
return result;
}
// build distance tree
initWorkArea(288);
result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
if (result != Z_OK || (bd[0] == 0 && nl > 257)){
if (result == Z_DATA_ERROR){
z.msg = "oversubscribed distance tree";
}
else if (result == Z_BUF_ERROR) {
z.msg = "incomplete distance tree";
result = Z_DATA_ERROR;
}
else if (result != Z_MEM_ERROR){
z.msg = "empty distance tree with lengths";
result = Z_DATA_ERROR;
}
return result;
}
return Z_OK;
}
static int inflate_trees_fixed(int[] bl, //literal desired/actual bit depth
int[] bd, //distance desired/actual bit depth
int[][] tl,//literal/length tree result
int[][] td,//distance tree result
ZStream z //for memory allocation
){
bl[0]=fixed_bl;
bd[0]=fixed_bd;
tl[0]=fixed_tl;
td[0]=fixed_td;
return Z_OK;
}
private void initWorkArea(int vsize){
if(hn==null){
hn=new int[1];
v=new int[vsize];
c=new int[BMAX+1];
r=new int[3];
u=new int[BMAX];
x=new int[BMAX+1];
}
if(v.length<vsize){ v=new int[vsize]; }
for(int i=0; i<vsize; i++){v[i]=0;}
for(int i=0; i<BMAX+1; i++){c[i]=0;}
for(int i=0; i<3; i++){r[i]=0;}
// for(int i=0; i<BMAX; i++){u[i]=0;}
System.arraycopy(c, 0, u, 0, BMAX);
// for(int i=0; i<BMAX+1; i++){x[i]=0;}
System.arraycopy(c, 0, x, 0, BMAX+1);
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final class Tree{
static final private int MAX_BITS=15;
static final private int BL_CODES=19;
static final private int D_CODES=30;
static final private int LITERALS=256;
static final private int LENGTH_CODES=29;
static final private int L_CODES=(LITERALS+1+LENGTH_CODES);
static final private int HEAP_SIZE=(2*L_CODES+1);
// Bit length codes must not exceed MAX_BL_BITS bits
static final int MAX_BL_BITS=7;
// end of block literal code
static final int END_BLOCK=256;
// repeat previous bit length 3-6 times (2 bits of repeat count)
static final int REP_3_6=16;
// repeat a zero length 3-10 times (3 bits of repeat count)
static final int REPZ_3_10=17;
// repeat a zero length 11-138 times (7 bits of repeat count)
static final int REPZ_11_138=18;
// extra bits for each length code
static final int[] extra_lbits={
0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0
};
// extra bits for each distance code
static final int[] extra_dbits={
0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13
};
// extra bits for each bit length code
static final int[] extra_blbits={
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7
};
static final byte[] bl_order={
16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
// The lengths of the bit length codes are sent in order of decreasing
// probability, to avoid transmitting the lengths for unused bit
// length codes.
static final int Buf_size=8*2;
// see definition of array dist_code below
static final int DIST_CODE_LEN=512;
static final byte[] _dist_code = {
0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
};
static final byte[] _length_code={
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
};
static final int[] base_length = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
64, 80, 96, 112, 128, 160, 192, 224, 0
};
static final int[] base_dist = {
0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
};
// Mapping from a distance to a distance code. dist is the distance - 1 and
// must not have side effects. _dist_code[256] and _dist_code[257] are never
// used.
static int d_code(int dist){
return ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>>7)]);
}
short[] dyn_tree; // the dynamic tree
int max_code; // largest code with non zero frequency
StaticTree stat_desc; // the corresponding static tree
// Compute the optimal bit lengths for a tree and update the total bit length
// for the current block.
// IN assertion: the fields freq and dad are set, heap[heap_max] and
// above are the tree nodes sorted by increasing frequency.
// OUT assertions: the field len is set to the optimal bit length, the
// array bl_count contains the frequencies for each bit length.
// The length opt_len is updated; static_len is also updated if stree is
// not null.
void gen_bitlen(Deflate s){
short[] tree = dyn_tree;
short[] stree = stat_desc.static_tree;
int[] extra = stat_desc.extra_bits;
int base = stat_desc.extra_base;
int max_length = stat_desc.max_length;
int h; // heap index
int n, m; // iterate over the tree elements
int bits; // bit length
int xbits; // extra bits
short f; // frequency
int overflow = 0; // number of elements with bit length too large
for (bits = 0; bits <= MAX_BITS; bits++) s.bl_count[bits] = 0;
// In a first pass, compute the optimal bit lengths (which may
// overflow in the case of the bit length tree).
tree[s.heap[s.heap_max]*2+1] = 0; // root of the heap
for(h=s.heap_max+1; h<HEAP_SIZE; h++){
n = s.heap[h];
bits = tree[tree[n*2+1]*2+1] + 1;
if (bits > max_length){ bits = max_length; overflow++; }
tree[n*2+1] = (short)bits;
// We overwrite tree[n*2+1] which is no longer needed
if (n > max_code) continue; // not a leaf node
s.bl_count[bits]++;
xbits = 0;
if (n >= base) xbits = extra[n-base];
f = tree[n*2];
s.opt_len += f * (bits + xbits);
if (stree!=null) s.static_len += f * (stree[n*2+1] + xbits);
}
if (overflow == 0) return;
// This happens for example on obj2 and pic of the Calgary corpus
// Find the first bit length which could increase:
do {
bits = max_length-1;
while(s.bl_count[bits]==0) bits--;
s.bl_count[bits]--; // move one leaf down the tree
s.bl_count[bits+1]+=2; // move one overflow item as its brother
s.bl_count[max_length]--;
// The brother of the overflow item also moves one step up,
// but this does not affect bl_count[max_length]
overflow -= 2;
}
while (overflow > 0);
for (bits = max_length; bits != 0; bits--) {
n = s.bl_count[bits];
while (n != 0) {
m = s.heap[--h];
if (m > max_code) continue;
if (tree[m*2+1] != bits) {
s.opt_len += ((long)bits - (long)tree[m*2+1])*(long)tree[m*2];
tree[m*2+1] = (short)bits;
}
n--;
}
}
}
// Construct one Huffman tree and assigns the code bit strings and lengths.
// Update the total bit length for the current block.
// IN assertion: the field freq is set for all tree elements.
// OUT assertions: the fields len and code are set to the optimal bit length
// and corresponding code. The length opt_len is updated; static_len is
// also updated if stree is not null. The field max_code is set.
void build_tree(Deflate s){
short[] tree=dyn_tree;
short[] stree=stat_desc.static_tree;
int elems=stat_desc.elems;
int n, m; // iterate over heap elements
int max_code=-1; // largest code with non zero frequency
int node; // new node being created
// Construct the initial heap, with least frequent element in
// heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
// heap[0] is not used.
s.heap_len = 0;
s.heap_max = HEAP_SIZE;
for(n=0; n<elems; n++) {
if(tree[n*2] != 0) {
s.heap[++s.heap_len] = max_code = n;
s.depth[n] = 0;
}
else{
tree[n*2+1] = 0;
}
}
// The pkzip format requires that at least one distance code exists,
// and that at least one bit should be sent even if there is only one
// possible code. So to avoid special checks later on we force at least
// two codes of non zero frequency.
while (s.heap_len < 2) {
node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
tree[node*2] = 1;
s.depth[node] = 0;
s.opt_len--; if (stree!=null) s.static_len -= stree[node*2+1];
// node is 0 or 1 so it does not have extra bits
}
this.max_code = max_code;
// The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
// establish sub-heaps of increasing lengths:
for(n=s.heap_len/2;n>=1; n--)
s.pqdownheap(tree, n);
// Construct the Huffman tree by repeatedly combining the least two
// frequent nodes.
node=elems; // next internal node of the tree
do{
// n = node of least frequency
n=s.heap[1];
s.heap[1]=s.heap[s.heap_len--];
s.pqdownheap(tree, 1);
m=s.heap[1]; // m = node of next least frequency
s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
s.heap[--s.heap_max] = m;
// Create a new node father of n and m
tree[node*2] = (short)(tree[n*2] + tree[m*2]);
s.depth[node] = (byte)(Math.max(s.depth[n],s.depth[m])+1);
tree[n*2+1] = tree[m*2+1] = (short)node;
// and insert the new node in the heap
s.heap[1] = node++;
s.pqdownheap(tree, 1);
}
while(s.heap_len>=2);
s.heap[--s.heap_max] = s.heap[1];
// At this point, the fields freq and dad are set. We can now
// generate the bit lengths.
gen_bitlen(s);
// The field len is now set, we can generate the bit codes
gen_codes(tree, max_code, s.bl_count);
}
// Generate the codes for a given tree and bit counts (which need not be
// optimal).
// IN assertion: the array bl_count contains the bit length statistics for
// the given tree and the field len is set for all tree elements.
// OUT assertion: the field code is set for all tree elements of non
// zero code length.
static void gen_codes(short[] tree, // the tree to decorate
int max_code, // largest code with non zero frequency
short[] bl_count // number of codes at each bit length
){
short[] next_code=new short[MAX_BITS+1]; // next code value for each bit length
short code = 0; // running code value
int bits; // bit index
int n; // code index
// The distribution counts are first used to generate the code values
// without bit reversal.
for (bits = 1; bits <= MAX_BITS; bits++) {
next_code[bits] = code = (short)((code + bl_count[bits-1]) << 1);
}
// Check that the bit counts in bl_count are consistent. The last code
// must be all ones.
//Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
// "inconsistent bit counts");
//Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
for (n = 0; n <= max_code; n++) {
int len = tree[n*2+1];
if (len == 0) continue;
// Now reverse the bits
tree[n*2] = (short)(bi_reverse(next_code[len]++, len));
}
}
// Reverse the first len bits of a code, using straightforward code (a faster
// method would use a table)
// IN assertion: 1 <= len <= 15
static int bi_reverse(int code, // the value to invert
int len // its bit length
){
int res = 0;
do{
res|=code&1;
code>>>=1;
res<<=1;
}
while(--len>0);
return res>>>1;
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final class InfBlocks{
static final private int MANY=1440;
// And'ing with mask[n] masks the lower n bits
static final private int[] inflate_mask = {
0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
0x00007fff, 0x0000ffff
};
// Table for deflate from PKZIP's appnote.txt.
static final int[] border = { // Order of the bit length code lengths
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
};
static final private int Z_OK=0;
static final private int Z_STREAM_END=1;
static final private int Z_NEED_DICT=2;
static final private int Z_ERRNO=-1;
static final private int Z_STREAM_ERROR=-2;
static final private int Z_DATA_ERROR=-3;
static final private int Z_MEM_ERROR=-4;
static final private int Z_BUF_ERROR=-5;
static final private int Z_VERSION_ERROR=-6;
static final private int TYPE=0; // get type bits (3, including end bit)
static final private int LENS=1; // get lengths for stored
static final private int STORED=2;// processing stored block
static final private int TABLE=3; // get table lengths
static final private int BTREE=4; // get bit lengths tree for a dynamic block
static final private int DTREE=5; // get length, distance trees for a dynamic block
static final private int CODES=6; // processing fixed or dynamic block
static final private int DRY=7; // output remaining window bytes
static final private int DONE=8; // finished last block, done
static final private int BAD=9; // ot a data error--stuck here
int mode; // current inflate_block mode
int left; // if STORED, bytes left to copy
int table; // table lengths (14 bits)
int index; // index into blens (or border)
int[] blens; // bit lengths of codes
int[] bb=new int[1]; // bit length tree depth
int[] tb=new int[1]; // bit length decoding tree
InfCodes codes=new InfCodes(); // if CODES, current state
int last; // true if this block is the last block
// mode independent information
int bitk; // bits in bit buffer
int bitb; // bit buffer
int[] hufts; // single malloc for tree space
byte[] window; // sliding window
int end; // one byte after sliding window
int read; // window read pointer
int write; // window write pointer
Object checkfn; // check function
long check; // check on output
InfTree inftree=new InfTree();
InfBlocks(ZStream z, Object checkfn, int w){
hufts=new int[MANY*3];
window=new byte[w];
end=w;
this.checkfn = checkfn;
mode = TYPE;
reset(z, null);
}
void reset(ZStream z, long[] c){
if(c!=null) c[0]=check;
if(mode==BTREE || mode==DTREE){
}
if(mode==CODES){
codes.free(z);
}
mode=TYPE;
bitk=0;
bitb=0;
read=write=0;
if(checkfn != null)
z.adler=check=z._adler.adler32(0L, null, 0, 0);
}
int proc(ZStream z, int r){
int t; // temporary storage
int b; // bit buffer
int k; // bits in bit buffer
int p; // input data pointer
int n; // bytes available there
int q; // output window write pointer
int m; // bytes to end of window or read pointer
// copy input/output information to locals (UPDATE macro restores)
{p=z.next_in_index;n=z.avail_in;b=bitb;k=bitk;}
{q=write;m=(int)(q<read?read-q-1:end-q);}
// process input based on current state
while(true){
switch (mode){
case TYPE:
while(k<(3)){
if(n!=0){
r=Z_OK;
}
else{
bitb=b; bitk=k;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
t = (int)(b & 7);
last = t & 1;
switch (t >>> 1){
case 0: // stored
{b>>>=(3);k-=(3);}
t = k & 7; // go to byte boundary
{b>>>=(t);k-=(t);}
mode = LENS; // get length of stored block
break;
case 1: // fixed
{
int[] bl=new int[1];
int[] bd=new int[1];
int[][] tl=new int[1][];
int[][] td=new int[1][];
InfTree.inflate_trees_fixed(bl, bd, tl, td, z);
codes.init(bl[0], bd[0], tl[0], 0, td[0], 0, z);
}
{b>>>=(3);k-=(3);}
mode = CODES;
break;
case 2: // dynamic
{b>>>=(3);k-=(3);}
mode = TABLE;
break;
case 3: // illegal
{b>>>=(3);k-=(3);}
mode = BAD;
z.msg = "invalid block type";
r = Z_DATA_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
break;
case LENS:
while(k<(32)){
if(n!=0){
r=Z_OK;
}
else{
bitb=b; bitk=k;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
if ((((~b) >>> 16) & 0xffff) != (b & 0xffff)){
mode = BAD;
z.msg = "invalid stored block lengths";
r = Z_DATA_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
left = (b & 0xffff);
b = k = 0; // dump bits
mode = left!=0 ? STORED : (last!=0 ? DRY : TYPE);
break;
case STORED:
if (n == 0){
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
if(m==0){
if(q==end&&read!=0){
q=0; m=(int)(q<read?read-q-1:end-q);
}
if(m==0){
write=q;
r=inflate_flush(z,r);
q=write;m=(int)(q<read?read-q-1:end-q);
if(q==end&&read!=0){
q=0; m=(int)(q<read?read-q-1:end-q);
}
if(m==0){
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
}
}
r=Z_OK;
t = left;
if(t>n) t = n;
if(t>m) t = m;
System.arraycopy(z.next_in, p, window, q, t);
p += t; n -= t;
q += t; m -= t;
if ((left -= t) != 0)
break;
mode = last!=0 ? DRY : TYPE;
break;
case TABLE:
while(k<(14)){
if(n!=0){
r=Z_OK;
}
else{
bitb=b; bitk=k;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
table = t = (b & 0x3fff);
if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
{
mode = BAD;
z.msg = "too many length or distance symbols";
r = Z_DATA_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
if(blens==null || blens.length<t){
blens=new int[t];
}
else{
for(int i=0; i<t; i++){blens[i]=0;}
}
{b>>>=(14);k-=(14);}
index = 0;
mode = BTREE;
case BTREE:
while (index < 4 + (table >>> 10)){
while(k<(3)){
if(n!=0){
r=Z_OK;
}
else{
bitb=b; bitk=k;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
blens[border[index++]] = b&7;
{b>>>=(3);k-=(3);}
}
while(index < 19){
blens[border[index++]] = 0;
}
bb[0] = 7;
t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z);
if (t != Z_OK){
r = t;
if (r == Z_DATA_ERROR){
blens=null;
mode = BAD;
}
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
index = 0;
mode = DTREE;
case DTREE:
while (true){
t = table;
if(!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))){
break;
}
int[] h;
int i, j, c;
t = bb[0];
while(k<(t)){
if(n!=0){
r=Z_OK;
}
else{
bitb=b; bitk=k;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
if(tb[0]==-1){
//System.err.println("null...");
}
t=hufts[(tb[0]+(b&inflate_mask[t]))*3+1];
c=hufts[(tb[0]+(b&inflate_mask[t]))*3+2];
if (c < 16){
b>>>=(t);k-=(t);
blens[index++] = c;
}
else { // c == 16..18
i = c == 18 ? 7 : c - 14;
j = c == 18 ? 11 : 3;
while(k<(t+i)){
if(n!=0){
r=Z_OK;
}
else{
bitb=b; bitk=k;
z.avail_in=n;
z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
};
n--;
b|=(z.next_in[p++]&0xff)<<k;
k+=8;
}
b>>>=(t);k-=(t);
j += (b & inflate_mask[i]);
b>>>=(i);k-=(i);
i = index;
t = table;
if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
(c == 16 && i < 1)){
blens=null;
mode = BAD;
z.msg = "invalid bit length repeat";
r = Z_DATA_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
c = c == 16 ? blens[i-1] : 0;
do{
blens[i++] = c;
}
while (--j!=0);
index = i;
}
}
tb[0]=-1;
{
int[] bl=new int[1];
int[] bd=new int[1];
int[] tl=new int[1];
int[] td=new int[1];
bl[0] = 9; // must be <= 9 for lookahead assumptions
bd[0] = 6; // must be <= 9 for lookahead assumptions
t = table;
t = inftree.inflate_trees_dynamic(257 + (t & 0x1f),
1 + ((t >> 5) & 0x1f),
blens, bl, bd, tl, td, hufts, z);
if (t != Z_OK){
if (t == Z_DATA_ERROR){
blens=null;
mode = BAD;
}
r = t;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z,r);
}
codes.init(bl[0], bd[0], hufts, tl[0], hufts, td[0], z);
}
mode = CODES;
case CODES:
bitb=b; bitk=k;
z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
if ((r = codes.proc(this, z, r)) != Z_STREAM_END){
return inflate_flush(z, r);
}
r = Z_OK;
codes.free(z);
p=z.next_in_index; n=z.avail_in;b=bitb;k=bitk;
q=write;m=(int)(q<read?read-q-1:end-q);
if (last==0){
mode = TYPE;
break;
}
mode = DRY;
case DRY:
write=q;
r=inflate_flush(z, r);
q=write; m=(int)(q<read?read-q-1:end-q);
if (read != write){
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z, r);
}
mode = DONE;
case DONE:
r = Z_STREAM_END;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z, r);
case BAD:
r = Z_DATA_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z, r);
default:
r = Z_STREAM_ERROR;
bitb=b; bitk=k;
z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
write=q;
return inflate_flush(z, r);
}
}
}
void free(ZStream z){
reset(z, null);
window=null;
hufts=null;
//ZFREE(z, s);
}
void set_dictionary(byte[] d, int start, int n){
System.arraycopy(d, start, window, 0, n);
read = write = n;
}
// Returns true if inflate is currently at the end of a block generated
// by Z_SYNC_FLUSH or Z_FULL_FLUSH.
int sync_point(){
return mode == LENS ? 1 : 0;
}
// copy as much as possible from the sliding window to the output area
int inflate_flush(ZStream z, int r){
int n;
int p;
int q;
// local copies of source and destination pointers
p = z.next_out_index;
q = read;
// compute number of bytes to copy as far as end of window
n = (int)((q <= write ? write : end) - q);
if (n > z.avail_out) n = z.avail_out;
if (n!=0 && r == Z_BUF_ERROR) r = Z_OK;
// update counters
z.avail_out -= n;
z.total_out += n;
// update check information
if(checkfn != null)
z.adler=check=z._adler.adler32(check, window, q, n);
// copy as far as end of window
System.arraycopy(window, q, z.next_out, p, n);
p += n;
q += n;
// see if more to copy at beginning of window
if (q == end){
// wrap pointers
q = 0;
if (write == end)
write = 0;
// compute bytes to copy
n = write - q;
if (n > z.avail_out) n = z.avail_out;
if (n!=0 && r == Z_BUF_ERROR) r = Z_OK;
// update counters
z.avail_out -= n;
z.total_out += n;
// update check information
if(checkfn != null)
z.adler=check=z._adler.adler32(check, window, q, n);
// copy
System.arraycopy(window, q, z.next_out, p, n);
p += n;
q += n;
}
// update pointers
z.next_out_index = p;
read = q;
// done
return r;
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final public class ZStream{
static final private int MAX_WBITS=15; // 32K LZ77 window
static final private int DEF_WBITS=MAX_WBITS;
static final private int Z_NO_FLUSH=0;
static final private int Z_PARTIAL_FLUSH=1;
static final private int Z_SYNC_FLUSH=2;
static final private int Z_FULL_FLUSH=3;
static final private int Z_FINISH=4;
static final private int MAX_MEM_LEVEL=9;
static final private int Z_OK=0;
static final private int Z_STREAM_END=1;
static final private int Z_NEED_DICT=2;
static final private int Z_ERRNO=-1;
static final private int Z_STREAM_ERROR=-2;
static final private int Z_DATA_ERROR=-3;
static final private int Z_MEM_ERROR=-4;
static final private int Z_BUF_ERROR=-5;
static final private int Z_VERSION_ERROR=-6;
public byte[] next_in; // next input byte
public int next_in_index;
public int avail_in; // number of bytes available at next_in
public long total_in; // total nb of input bytes read so far
public byte[] next_out; // next output byte should be put there
public int next_out_index;
public int avail_out; // remaining free space at next_out
public long total_out; // total nb of bytes output so far
public String msg;
Deflate dstate;
Inflate istate;
int data_type; // best guess about the data type: ascii or binary
public long adler;
Adler32 _adler=new Adler32();
public int inflateInit(){
return inflateInit(DEF_WBITS);
}
public int inflateInit(boolean nowrap){
return inflateInit(DEF_WBITS, nowrap);
}
public int inflateInit(int w){
return inflateInit(w, false);
}
public int inflateInit(int w, boolean nowrap){
istate=new Inflate();
return istate.inflateInit(this, nowrap?-w:w);
}
public int inflate(int f){
if(istate==null) return Z_STREAM_ERROR;
return istate.inflate(this, f);
}
public int inflateEnd(){
if(istate==null) return Z_STREAM_ERROR;
int ret=istate.inflateEnd(this);
istate = null;
return ret;
}
public int inflateSync(){
if(istate == null)
return Z_STREAM_ERROR;
return istate.inflateSync(this);
}
public int inflateSetDictionary(byte[] dictionary, int dictLength){
if(istate == null)
return Z_STREAM_ERROR;
return istate.inflateSetDictionary(this, dictionary, dictLength);
}
public int deflateInit(int level){
return deflateInit(level, MAX_WBITS);
}
public int deflateInit(int level, boolean nowrap){
return deflateInit(level, MAX_WBITS, nowrap);
}
public int deflateInit(int level, int bits){
return deflateInit(level, bits, false);
}
public int deflateInit(int level, int bits, boolean nowrap){
dstate=new Deflate();
return dstate.deflateInit(this, level, nowrap?-bits:bits);
}
public int deflate(int flush){
if(dstate==null){
return Z_STREAM_ERROR;
}
return dstate.deflate(this, flush);
}
public int deflateEnd(){
if(dstate==null) return Z_STREAM_ERROR;
int ret=dstate.deflateEnd();
dstate=null;
return ret;
}
public int deflateParams(int level, int strategy){
if(dstate==null) return Z_STREAM_ERROR;
return dstate.deflateParams(this, level, strategy);
}
public int deflateSetDictionary (byte[] dictionary, int dictLength){
if(dstate == null)
return Z_STREAM_ERROR;
return dstate.deflateSetDictionary(this, dictionary, dictLength);
}
// Flush as much pending output as possible. All deflate() output goes
// through this function so some applications may wish to modify it
// to avoid allocating a large strm->next_out buffer and copying into it.
// (See also read_buf()).
void flush_pending(){
int len=dstate.pending;
if(len>avail_out) len=avail_out;
if(len==0) return;
if(dstate.pending_buf.length<=dstate.pending_out ||
next_out.length<=next_out_index ||
dstate.pending_buf.length<(dstate.pending_out+len) ||
next_out.length<(next_out_index+len)){
System.out.println(dstate.pending_buf.length+", "+dstate.pending_out+
", "+next_out.length+", "+next_out_index+", "+len);
System.out.println("avail_out="+avail_out);
}
System.arraycopy(dstate.pending_buf, dstate.pending_out,
next_out, next_out_index, len);
next_out_index+=len;
dstate.pending_out+=len;
total_out+=len;
avail_out-=len;
dstate.pending-=len;
if(dstate.pending==0){
dstate.pending_out=0;
}
}
// Read a new buffer from the current input stream, update the adler32
// and total number of bytes read. All deflate() input goes through
// this function so some applications may wish to modify it to avoid
// allocating a large strm->next_in buffer and copying from it.
// (See also flush_pending()).
int read_buf(byte[] buf, int start, int size) {
int len=avail_in;
if(len>size) len=size;
if(len==0) return 0;
avail_in-=len;
if(dstate.noheader==0) {
adler=_adler.adler32(adler, next_in, next_in_index, len);
}
System.arraycopy(next_in, next_in_index, buf, start, len);
next_in_index += len;
total_in += len;
return len;
}
public void free(){
next_in=null;
next_out=null;
msg=null;
_adler=null;
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final class Inflate{
static final private int MAX_WBITS=15; // 32K LZ77 window
// preset dictionary flag in zlib header
static final private int PRESET_DICT=0x20;
static final int Z_NO_FLUSH=0;
static final int Z_PARTIAL_FLUSH=1;
static final int Z_SYNC_FLUSH=2;
static final int Z_FULL_FLUSH=3;
static final int Z_FINISH=4;
static final private int Z_DEFLATED=8;
static final private int Z_OK=0;
static final private int Z_STREAM_END=1;
static final private int Z_NEED_DICT=2;
static final private int Z_ERRNO=-1;
static final private int Z_STREAM_ERROR=-2;
static final private int Z_DATA_ERROR=-3;
static final private int Z_MEM_ERROR=-4;
static final private int Z_BUF_ERROR=-5;
static final private int Z_VERSION_ERROR=-6;
static final private int METHOD=0; // waiting for method byte
static final private int FLAG=1; // waiting for flag byte
static final private int DICT4=2; // four dictionary check bytes to go
static final private int DICT3=3; // three dictionary check bytes to go
static final private int DICT2=4; // two dictionary check bytes to go
static final private int DICT1=5; // one dictionary check byte to go
static final private int DICT0=6; // waiting for inflateSetDictionary
static final private int BLOCKS=7; // decompressing blocks
static final private int CHECK4=8; // four check bytes to go
static final private int CHECK3=9; // three check bytes to go
static final private int CHECK2=10; // two check bytes to go
static final private int CHECK1=11; // one check byte to go
static final private int DONE=12; // finished check, done
static final private int BAD=13; // got an error--stay here
int mode; // current inflate mode
// mode dependent information
int method; // if FLAGS, method byte
// if CHECK, check values to compare
long[] was=new long[1] ; // computed check value
long need; // stream check value
// if BAD, inflateSync's marker bytes count
int marker;
// mode independent information
int nowrap; // flag for no wrapper
int wbits; // log2(window size) (8..15, defaults to 15)
InfBlocks blocks; // current inflate_blocks state
int inflateReset(ZStream z){
if(z == null || z.istate == null) return Z_STREAM_ERROR;
z.total_in = z.total_out = 0;
z.msg = null;
z.istate.mode = z.istate.nowrap!=0 ? BLOCKS : METHOD;
z.istate.blocks.reset(z, null);
return Z_OK;
}
int inflateEnd(ZStream z){
if(blocks != null)
blocks.free(z);
blocks=null;
// ZFREE(z, z->state);
return Z_OK;
}
int inflateInit(ZStream z, int w){
z.msg = null;
blocks = null;
// handle undocumented nowrap option (no zlib header or check)
nowrap = 0;
if(w < 0){
w = - w;
nowrap = 1;
}
// set window size
if(w<8 ||w>15){
inflateEnd(z);
return Z_STREAM_ERROR;
}
wbits=w;
z.istate.blocks=new InfBlocks(z,
z.istate.nowrap!=0 ? null : this,
1<<w);
// reset state
inflateReset(z);
return Z_OK;
}
int inflate(ZStream z, int f){
int r;
int b;
if(z == null || z.istate == null || z.next_in == null)
return Z_STREAM_ERROR;
f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
r = Z_BUF_ERROR;
while (true){
//System.out.println("mode: "+z.istate.mode);
switch (z.istate.mode){
case METHOD:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
if(((z.istate.method = z.next_in[z.next_in_index++])&0xf)!=Z_DEFLATED){
z.istate.mode = BAD;
z.msg="unknown compression method";
z.istate.marker = 5; // can't try inflateSync
break;
}
if((z.istate.method>>4)+8>z.istate.wbits){
z.istate.mode = BAD;
z.msg="invalid window size";
z.istate.marker = 5; // can't try inflateSync
break;
}
z.istate.mode=FLAG;
case FLAG:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
b = (z.next_in[z.next_in_index++])&0xff;
if((((z.istate.method << 8)+b) % 31)!=0){
z.istate.mode = BAD;
z.msg = "incorrect header check";
z.istate.marker = 5; // can't try inflateSync
break;
}
if((b&PRESET_DICT)==0){
z.istate.mode = BLOCKS;
break;
}
z.istate.mode = DICT4;
case DICT4:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
z.istate.mode=DICT3;
case DICT3:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
z.istate.mode=DICT2;
case DICT2:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
z.istate.mode=DICT1;
case DICT1:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need += (z.next_in[z.next_in_index++]&0xffL);
z.adler = z.istate.need;
z.istate.mode = DICT0;
return Z_NEED_DICT;
case DICT0:
z.istate.mode = BAD;
z.msg = "need dictionary";
z.istate.marker = 0; // can try inflateSync
return Z_STREAM_ERROR;
case BLOCKS:
r = z.istate.blocks.proc(z, r);
if(r == Z_DATA_ERROR){
z.istate.mode = BAD;
z.istate.marker = 0; // can try inflateSync
break;
}
if(r == Z_OK){
r = f;
}
if(r != Z_STREAM_END){
return r;
}
r = f;
z.istate.blocks.reset(z, z.istate.was);
if(z.istate.nowrap!=0){
z.istate.mode=DONE;
break;
}
z.istate.mode=CHECK4;
case CHECK4:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
z.istate.mode=CHECK3;
case CHECK3:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
z.istate.mode = CHECK2;
case CHECK2:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
z.istate.mode = CHECK1;
case CHECK1:
if(z.avail_in==0)return r;r=f;
z.avail_in--; z.total_in++;
z.istate.need+=(z.next_in[z.next_in_index++]&0xffL);
if(((int)(z.istate.was[0])) != ((int)(z.istate.need))){
z.istate.mode = BAD;
z.msg = "incorrect data check";
z.istate.marker = 5; // can't try inflateSync
break;
}
z.istate.mode = DONE;
case DONE:
return Z_STREAM_END;
case BAD:
return Z_DATA_ERROR;
default:
return Z_STREAM_ERROR;
}
}
}
int inflateSetDictionary(ZStream z, byte[] dictionary, int dictLength){
int index=0;
int length = dictLength;
if(z==null || z.istate == null|| z.istate.mode != DICT0)
return Z_STREAM_ERROR;
if(z._adler.adler32(1L, dictionary, 0, dictLength)!=z.adler){
return Z_DATA_ERROR;
}
z.adler = z._adler.adler32(0, null, 0, 0);
if(length >= (1<<z.istate.wbits)){
length = (1<<z.istate.wbits)-1;
index=dictLength - length;
}
z.istate.blocks.set_dictionary(dictionary, index, length);
z.istate.mode = BLOCKS;
return Z_OK;
}
static private byte[] mark = {(byte)0, (byte)0, (byte)0xff, (byte)0xff};
int inflateSync(ZStream z){
int n; // number of bytes to look at
int p; // pointer to bytes
int m; // number of marker bytes found in a row
long r, w; // temporaries to save total_in and total_out
// set up
if(z == null || z.istate == null)
return Z_STREAM_ERROR;
if(z.istate.mode != BAD){
z.istate.mode = BAD;
z.istate.marker = 0;
}
if((n=z.avail_in)==0)
return Z_BUF_ERROR;
p=z.next_in_index;
m=z.istate.marker;
// search
while (n!=0 && m < 4){
if(z.next_in[p] == mark[m]){
m++;
}
else if(z.next_in[p]!=0){
m = 0;
}
else{
m = 4 - m;
}
p++; n--;
}
// restore
z.total_in += p-z.next_in_index;
z.next_in_index = p;
z.avail_in = n;
z.istate.marker = m;
// return no joy or set up to restart on a new block
if(m != 4){
return Z_DATA_ERROR;
}
r=z.total_in; w=z.total_out;
inflateReset(z);
z.total_in=r; z.total_out = w;
z.istate.mode = BLOCKS;
return Z_OK;
}
// Returns true if inflate is currently at the end of a block generated
// by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
// implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
// but removes the length bytes of the resulting empty stored block. When
// decompressing, PPP checks that at the end of input packet, inflate is
// waiting for these length bytes.
int inflateSyncPoint(ZStream z){
if(z == null || z.istate == null || z.istate.blocks == null)
return Z_STREAM_ERROR;
return z.istate.blocks.sync_point();
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final class StaticTree{
static final private int MAX_BITS=15;
static final private int BL_CODES=19;
static final private int D_CODES=30;
static final private int LITERALS=256;
static final private int LENGTH_CODES=29;
static final private int L_CODES=(LITERALS+1+LENGTH_CODES);
// Bit length codes must not exceed MAX_BL_BITS bits
static final int MAX_BL_BITS=7;
static final short[] static_ltree = {
12, 8, 140, 8, 76, 8, 204, 8, 44, 8,
172, 8, 108, 8, 236, 8, 28, 8, 156, 8,
92, 8, 220, 8, 60, 8, 188, 8, 124, 8,
252, 8, 2, 8, 130, 8, 66, 8, 194, 8,
34, 8, 162, 8, 98, 8, 226, 8, 18, 8,
146, 8, 82, 8, 210, 8, 50, 8, 178, 8,
114, 8, 242, 8, 10, 8, 138, 8, 74, 8,
202, 8, 42, 8, 170, 8, 106, 8, 234, 8,
26, 8, 154, 8, 90, 8, 218, 8, 58, 8,
186, 8, 122, 8, 250, 8, 6, 8, 134, 8,
70, 8, 198, 8, 38, 8, 166, 8, 102, 8,
230, 8, 22, 8, 150, 8, 86, 8, 214, 8,
54, 8, 182, 8, 118, 8, 246, 8, 14, 8,
142, 8, 78, 8, 206, 8, 46, 8, 174, 8,
110, 8, 238, 8, 30, 8, 158, 8, 94, 8,
222, 8, 62, 8, 190, 8, 126, 8, 254, 8,
1, 8, 129, 8, 65, 8, 193, 8, 33, 8,
161, 8, 97, 8, 225, 8, 17, 8, 145, 8,
81, 8, 209, 8, 49, 8, 177, 8, 113, 8,
241, 8, 9, 8, 137, 8, 73, 8, 201, 8,
41, 8, 169, 8, 105, 8, 233, 8, 25, 8,
153, 8, 89, 8, 217, 8, 57, 8, 185, 8,
121, 8, 249, 8, 5, 8, 133, 8, 69, 8,
197, 8, 37, 8, 165, 8, 101, 8, 229, 8,
21, 8, 149, 8, 85, 8, 213, 8, 53, 8,
181, 8, 117, 8, 245, 8, 13, 8, 141, 8,
77, 8, 205, 8, 45, 8, 173, 8, 109, 8,
237, 8, 29, 8, 157, 8, 93, 8, 221, 8,
61, 8, 189, 8, 125, 8, 253, 8, 19, 9,
275, 9, 147, 9, 403, 9, 83, 9, 339, 9,
211, 9, 467, 9, 51, 9, 307, 9, 179, 9,
435, 9, 115, 9, 371, 9, 243, 9, 499, 9,
11, 9, 267, 9, 139, 9, 395, 9, 75, 9,
331, 9, 203, 9, 459, 9, 43, 9, 299, 9,
171, 9, 427, 9, 107, 9, 363, 9, 235, 9,
491, 9, 27, 9, 283, 9, 155, 9, 411, 9,
91, 9, 347, 9, 219, 9, 475, 9, 59, 9,
315, 9, 187, 9, 443, 9, 123, 9, 379, 9,
251, 9, 507, 9, 7, 9, 263, 9, 135, 9,
391, 9, 71, 9, 327, 9, 199, 9, 455, 9,
39, 9, 295, 9, 167, 9, 423, 9, 103, 9,
359, 9, 231, 9, 487, 9, 23, 9, 279, 9,
151, 9, 407, 9, 87, 9, 343, 9, 215, 9,
471, 9, 55, 9, 311, 9, 183, 9, 439, 9,
119, 9, 375, 9, 247, 9, 503, 9, 15, 9,
271, 9, 143, 9, 399, 9, 79, 9, 335, 9,
207, 9, 463, 9, 47, 9, 303, 9, 175, 9,
431, 9, 111, 9, 367, 9, 239, 9, 495, 9,
31, 9, 287, 9, 159, 9, 415, 9, 95, 9,
351, 9, 223, 9, 479, 9, 63, 9, 319, 9,
191, 9, 447, 9, 127, 9, 383, 9, 255, 9,
511, 9, 0, 7, 64, 7, 32, 7, 96, 7,
16, 7, 80, 7, 48, 7, 112, 7, 8, 7,
72, 7, 40, 7, 104, 7, 24, 7, 88, 7,
56, 7, 120, 7, 4, 7, 68, 7, 36, 7,
100, 7, 20, 7, 84, 7, 52, 7, 116, 7,
3, 8, 131, 8, 67, 8, 195, 8, 35, 8,
163, 8, 99, 8, 227, 8
};
static final short[] static_dtree = {
0, 5, 16, 5, 8, 5, 24, 5, 4, 5,
20, 5, 12, 5, 28, 5, 2, 5, 18, 5,
10, 5, 26, 5, 6, 5, 22, 5, 14, 5,
30, 5, 1, 5, 17, 5, 9, 5, 25, 5,
5, 5, 21, 5, 13, 5, 29, 5, 3, 5,
19, 5, 11, 5, 27, 5, 7, 5, 23, 5
};
static StaticTree static_l_desc =
new StaticTree(static_ltree, Tree.extra_lbits,
LITERALS+1, L_CODES, MAX_BITS);
static StaticTree static_d_desc =
new StaticTree(static_dtree, Tree.extra_dbits,
0, D_CODES, MAX_BITS);
static StaticTree static_bl_desc =
new StaticTree(null, Tree.extra_blbits,
0, BL_CODES, MAX_BL_BITS);
short[] static_tree; // static tree or null
int[] extra_bits; // extra bits for each code or null
int extra_base; // base index for extra_bits
int elems; // max number of elements in the tree
int max_length; // max bit length for the codes
StaticTree(short[] static_tree,
int[] extra_bits,
int extra_base,
int elems,
int max_length
){
this.static_tree=static_tree;
this.extra_bits=extra_bits;
this.extra_base=extra_base;
this.elems=elems;
this.max_length=max_length;
}
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
final class Adler32{
// largest prime smaller than 65536
static final private int BASE=65521;
// NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
static final private int NMAX=5552;
long adler32(long adler, byte[] buf, int index, int len){
if(buf == null){ return 1L; }
long s1=adler&0xffff;
long s2=(adler>>16)&0xffff;
int k;
while(len > 0) {
k=len<NMAX?len:NMAX;
len-=k;
while(k>=16){
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
s1+=buf[index++]&0xff; s2+=s1;
k-=16;
}
if(k!=0){
do{
s1+=buf[index++]&0xff; s2+=s1;
}
while(--k!=0);
}
s1%=BASE;
s2%=BASE;
}
return (s2<<16)|s1;
}
/*
private java.util.zip.Adler32 adler=new java.util.zip.Adler32();
long adler32(long value, byte[] buf, int index, int len){
if(value==1) {adler.reset();}
if(buf==null) {adler.reset();}
else{adler.update(buf, index, len);}
return adler.getValue();
}
*/
}
| Java |
/* -*-mode:java; c-basic-offset:2; -*- */
/*
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This program is based on zlib-1.1.3, so all credit should go authors
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
* and contributors of zlib.
*/
package com.jcraft.jzlib;
public
final class Deflate{
static final private int MAX_MEM_LEVEL=9;
static final private int Z_DEFAULT_COMPRESSION=-1;
static final private int MAX_WBITS=15; // 32K LZ77 window
static final private int DEF_MEM_LEVEL=8;
static class Config{
int good_length; // reduce lazy search above this match length
int max_lazy; // do not perform lazy search above this match length
int nice_length; // quit search above this match length
int max_chain;
int func;
Config(int good_length, int max_lazy,
int nice_length, int max_chain, int func){
this.good_length=good_length;
this.max_lazy=max_lazy;
this.nice_length=nice_length;
this.max_chain=max_chain;
this.func=func;
}
}
static final private int STORED=0;
static final private int FAST=1;
static final private int SLOW=2;
static final private Config[] config_table;
static{
config_table=new Config[10];
// good lazy nice chain
config_table[0]=new Config(0, 0, 0, 0, STORED);
config_table[1]=new Config(4, 4, 8, 4, FAST);
config_table[2]=new Config(4, 5, 16, 8, FAST);
config_table[3]=new Config(4, 6, 32, 32, FAST);
config_table[4]=new Config(4, 4, 16, 16, SLOW);
config_table[5]=new Config(8, 16, 32, 32, SLOW);
config_table[6]=new Config(8, 16, 128, 128, SLOW);
config_table[7]=new Config(8, 32, 128, 256, SLOW);
config_table[8]=new Config(32, 128, 258, 1024, SLOW);
config_table[9]=new Config(32, 258, 258, 4096, SLOW);
}
static final private String[] z_errmsg = {
"need dictionary", // Z_NEED_DICT 2
"stream end", // Z_STREAM_END 1
"", // Z_OK 0
"file error", // Z_ERRNO (-1)
"stream error", // Z_STREAM_ERROR (-2)
"data error", // Z_DATA_ERROR (-3)
"insufficient memory", // Z_MEM_ERROR (-4)
"buffer error", // Z_BUF_ERROR (-5)
"incompatible version",// Z_VERSION_ERROR (-6)
""
};
// block not completed, need more input or more output
static final private int NeedMore=0;
// block flush performed
static final private int BlockDone=1;
// finish started, need only more output at next deflate
static final private int FinishStarted=2;
// finish done, accept no more input or output
static final private int FinishDone=3;
// preset dictionary flag in zlib header
static final private int PRESET_DICT=0x20;
static final private int Z_FILTERED=1;
static final private int Z_HUFFMAN_ONLY=2;
static final private int Z_DEFAULT_STRATEGY=0;
static final private int Z_NO_FLUSH=0;
static final private int Z_PARTIAL_FLUSH=1;
static final private int Z_SYNC_FLUSH=2;
static final private int Z_FULL_FLUSH=3;
static final private int Z_FINISH=4;
static final private int Z_OK=0;
static final private int Z_STREAM_END=1;
static final private int Z_NEED_DICT=2;
static final private int Z_ERRNO=-1;
static final private int Z_STREAM_ERROR=-2;
static final private int Z_DATA_ERROR=-3;
static final private int Z_MEM_ERROR=-4;
static final private int Z_BUF_ERROR=-5;
static final private int Z_VERSION_ERROR=-6;
static final private int INIT_STATE=42;
static final private int BUSY_STATE=113;
static final private int FINISH_STATE=666;
// The deflate compression method
static final private int Z_DEFLATED=8;
static final private int STORED_BLOCK=0;
static final private int STATIC_TREES=1;
static final private int DYN_TREES=2;
// The three kinds of block type
static final private int Z_BINARY=0;
static final private int Z_ASCII=1;
static final private int Z_UNKNOWN=2;
static final private int Buf_size=8*2;
// repeat previous bit length 3-6 times (2 bits of repeat count)
static final private int REP_3_6=16;
// repeat a zero length 3-10 times (3 bits of repeat count)
static final private int REPZ_3_10=17;
// repeat a zero length 11-138 times (7 bits of repeat count)
static final private int REPZ_11_138=18;
static final private int MIN_MATCH=3;
static final private int MAX_MATCH=258;
static final private int MIN_LOOKAHEAD=(MAX_MATCH+MIN_MATCH+1);
static final private int MAX_BITS=15;
static final private int D_CODES=30;
static final private int BL_CODES=19;
static final private int LENGTH_CODES=29;
static final private int LITERALS=256;
static final private int L_CODES=(LITERALS+1+LENGTH_CODES);
static final private int HEAP_SIZE=(2*L_CODES+1);
static final private int END_BLOCK=256;
ZStream strm; // pointer back to this zlib stream
int status; // as the name implies
byte[] pending_buf; // output still pending
int pending_buf_size; // size of pending_buf
int pending_out; // next pending byte to output to the stream
int pending; // nb of bytes in the pending buffer
int noheader; // suppress zlib header and adler32
byte data_type; // UNKNOWN, BINARY or ASCII
byte method; // STORED (for zip only) or DEFLATED
int last_flush; // value of flush param for previous deflate call
int w_size; // LZ77 window size (32K by default)
int w_bits; // log2(w_size) (8..16)
int w_mask; // w_size - 1
byte[] window;
// Sliding window. Input bytes are read into the second half of the window,
// and move to the first half later to keep a dictionary of at least wSize
// bytes. With this organization, matches are limited to a distance of
// wSize-MAX_MATCH bytes, but this ensures that IO is always
// performed with a length multiple of the block size. Also, it limits
// the window size to 64K, which is quite useful on MSDOS.
// To do: use the user input buffer as sliding window.
int window_size;
// Actual size of window: 2*wSize, except when the user input buffer
// is directly used as sliding window.
short[] prev;
// Link to older string with same hash index. To limit the size of this
// array to 64K, this link is maintained only for the last 32K strings.
// An index in this array is thus a window index modulo 32K.
short[] head; // Heads of the hash chains or NIL.
int ins_h; // hash index of string to be inserted
int hash_size; // number of elements in hash table
int hash_bits; // log2(hash_size)
int hash_mask; // hash_size-1
// Number of bits by which ins_h must be shifted at each input
// step. It must be such that after MIN_MATCH steps, the oldest
// byte no longer takes part in the hash key, that is:
// hash_shift * MIN_MATCH >= hash_bits
int hash_shift;
// Window position at the beginning of the current output block. Gets
// negative when the window is moved backwards.
int block_start;
int match_length; // length of best match
int prev_match; // previous match
int match_available; // set if previous match exists
int strstart; // start of string to insert
int match_start; // start of matching string
int lookahead; // number of valid bytes ahead in window
// Length of the best match at previous step. Matches not greater than this
// are discarded. This is used in the lazy match evaluation.
int prev_length;
// To speed up deflation, hash chains are never searched beyond this
// length. A higher limit improves compression ratio but degrades the speed.
int max_chain_length;
// Attempt to find a better match only when the current match is strictly
// smaller than this value. This mechanism is used only for compression
// levels >= 4.
int max_lazy_match;
// Insert new strings in the hash table only if the match length is not
// greater than this length. This saves time but degrades compression.
// max_insert_length is used only for compression levels <= 3.
int level; // compression level (1..9)
int strategy; // favor or force Huffman coding
// Use a faster search when the previous match is longer than this
int good_match;
// Stop searching when current match exceeds this
int nice_match;
short[] dyn_ltree; // literal and length tree
short[] dyn_dtree; // distance tree
short[] bl_tree; // Huffman tree for bit lengths
Tree l_desc=new Tree(); // desc for literal tree
Tree d_desc=new Tree(); // desc for distance tree
Tree bl_desc=new Tree(); // desc for bit length tree
// number of codes at each bit length for an optimal tree
short[] bl_count=new short[MAX_BITS+1];
// heap used to build the Huffman trees
int[] heap=new int[2*L_CODES+1];
int heap_len; // number of elements in the heap
int heap_max; // element of largest frequency
// The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
// The same heap array is used to build all trees.
// Depth of each subtree used as tie breaker for trees of equal frequency
byte[] depth=new byte[2*L_CODES+1];
int l_buf; // index for literals or lengths */
// Size of match buffer for literals/lengths. There are 4 reasons for
// limiting lit_bufsize to 64K:
// - frequencies can be kept in 16 bit counters
// - if compression is not successful for the first block, all input
// data is still in the window so we can still emit a stored block even
// when input comes from standard input. (This can also be done for
// all blocks if lit_bufsize is not greater than 32K.)
// - if compression is not successful for a file smaller than 64K, we can
// even emit a stored file instead of a stored block (saving 5 bytes).
// This is applicable only for zip (not gzip or zlib).
// - creating new Huffman trees less frequently may not provide fast
// adaptation to changes in the input data statistics. (Take for
// example a binary file with poorly compressible code followed by
// a highly compressible string table.) Smaller buffer sizes give
// fast adaptation but have of course the overhead of transmitting
// trees more frequently.
// - I can't count above 4
int lit_bufsize;
int last_lit; // running index in l_buf
// Buffer for distances. To simplify the code, d_buf and l_buf have
// the same number of elements. To use different lengths, an extra flag
// array would be necessary.
int d_buf; // index of pendig_buf
int opt_len; // bit length of current block with optimal trees
int static_len; // bit length of current block with static trees
int matches; // number of string matches in current block
int last_eob_len; // bit length of EOB code for last block
// Output buffer. bits are inserted starting at the bottom (least
// significant bits).
short bi_buf;
// Number of valid bits in bi_buf. All bits above the last valid bit
// are always zero.
int bi_valid;
Deflate(){
dyn_ltree=new short[HEAP_SIZE*2];
dyn_dtree=new short[(2*D_CODES+1)*2]; // distance tree
bl_tree=new short[(2*BL_CODES+1)*2]; // Huffman tree for bit lengths
}
void lm_init() {
window_size=2*w_size;
head[hash_size-1]=0;
for(int i=0; i<hash_size-1; i++){
head[i]=0;
}
// Set the default configuration parameters:
max_lazy_match = Deflate.config_table[level].max_lazy;
good_match = Deflate.config_table[level].good_length;
nice_match = Deflate.config_table[level].nice_length;
max_chain_length = Deflate.config_table[level].max_chain;
strstart = 0;
block_start = 0;
lookahead = 0;
match_length = prev_length = MIN_MATCH-1;
match_available = 0;
ins_h = 0;
}
// Initialize the tree data structures for a new zlib stream.
void tr_init(){
l_desc.dyn_tree = dyn_ltree;
l_desc.stat_desc = StaticTree.static_l_desc;
d_desc.dyn_tree = dyn_dtree;
d_desc.stat_desc = StaticTree.static_d_desc;
bl_desc.dyn_tree = bl_tree;
bl_desc.stat_desc = StaticTree.static_bl_desc;
bi_buf = 0;
bi_valid = 0;
last_eob_len = 8; // enough lookahead for inflate
// Initialize the first block of the first file:
init_block();
}
void init_block(){
// Initialize the trees.
for(int i = 0; i < L_CODES; i++) dyn_ltree[i*2] = 0;
for(int i= 0; i < D_CODES; i++) dyn_dtree[i*2] = 0;
for(int i= 0; i < BL_CODES; i++) bl_tree[i*2] = 0;
dyn_ltree[END_BLOCK*2] = 1;
opt_len = static_len = 0;
last_lit = matches = 0;
}
// Restore the heap property by moving down the tree starting at node k,
// exchanging a node with the smallest of its two sons if necessary, stopping
// when the heap property is re-established (each father smaller than its
// two sons).
void pqdownheap(short[] tree, // the tree to restore
int k // node to move down
){
int v = heap[k];
int j = k << 1; // left son of k
while (j <= heap_len) {
// Set j to the smallest of the two sons:
if (j < heap_len &&
smaller(tree, heap[j+1], heap[j], depth)){
j++;
}
// Exit if v is smaller than both sons
if(smaller(tree, v, heap[j], depth)) break;
// Exchange v with the smallest son
heap[k]=heap[j]; k = j;
// And continue down the tree, setting j to the left son of k
j <<= 1;
}
heap[k] = v;
}
static boolean smaller(short[] tree, int n, int m, byte[] depth){
short tn2=tree[n*2];
short tm2=tree[m*2];
return (tn2<tm2 ||
(tn2==tm2 && depth[n] <= depth[m]));
}
// Scan a literal or distance tree to determine the frequencies of the codes
// in the bit length tree.
void scan_tree (short[] tree,// the tree to be scanned
int max_code // and its largest code of non zero frequency
){
int n; // iterates over all tree elements
int prevlen = -1; // last emitted length
int curlen; // length of current code
int nextlen = tree[0*2+1]; // length of next code
int count = 0; // repeat count of the current code
int max_count = 7; // max repeat count
int min_count = 4; // min repeat count
if (nextlen == 0){ max_count = 138; min_count = 3; }
tree[(max_code+1)*2+1] = (short)0xffff; // guard
for(n = 0; n <= max_code; n++) {
curlen = nextlen; nextlen = tree[(n+1)*2+1];
if(++count < max_count && curlen == nextlen) {
continue;
}
else if(count < min_count) {
bl_tree[curlen*2] += count;
}
else if(curlen != 0) {
if(curlen != prevlen) bl_tree[curlen*2]++;
bl_tree[REP_3_6*2]++;
}
else if(count <= 10) {
bl_tree[REPZ_3_10*2]++;
}
else{
bl_tree[REPZ_11_138*2]++;
}
count = 0; prevlen = curlen;
if(nextlen == 0) {
max_count = 138; min_count = 3;
}
else if(curlen == nextlen) {
max_count = 6; min_count = 3;
}
else{
max_count = 7; min_count = 4;
}
}
}
// Construct the Huffman tree for the bit lengths and return the index in
// bl_order of the last bit length code to send.
int build_bl_tree(){
int max_blindex; // index of last bit length code of non zero freq
// Determine the bit length frequencies for literal and distance trees
scan_tree(dyn_ltree, l_desc.max_code);
scan_tree(dyn_dtree, d_desc.max_code);
// Build the bit length tree:
bl_desc.build_tree(this);
// opt_len now includes the length of the tree representations, except
// the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
// Determine the number of bit length codes to send. The pkzip format
// requires that at least 4 bit length codes be sent. (appnote.txt says
// 3 but the actual value used is 4.)
for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
if (bl_tree[Tree.bl_order[max_blindex]*2+1] != 0) break;
}
// Update opt_len to include the bit length tree and counts
opt_len += 3*(max_blindex+1) + 5+5+4;
return max_blindex;
}
// Send the header for a block using dynamic Huffman trees: the counts, the
// lengths of the bit length codes, the literal tree and the distance tree.
// IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
void send_all_trees(int lcodes, int dcodes, int blcodes){
int rank; // index in bl_order
send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt
send_bits(dcodes-1, 5);
send_bits(blcodes-4, 4); // not -3 as stated in appnote.txt
for (rank = 0; rank < blcodes; rank++) {
send_bits(bl_tree[Tree.bl_order[rank]*2+1], 3);
}
send_tree(dyn_ltree, lcodes-1); // literal tree
send_tree(dyn_dtree, dcodes-1); // distance tree
}
// Send a literal or distance tree in compressed form, using the codes in
// bl_tree.
void send_tree (short[] tree,// the tree to be sent
int max_code // and its largest code of non zero frequency
){
int n; // iterates over all tree elements
int prevlen = -1; // last emitted length
int curlen; // length of current code
int nextlen = tree[0*2+1]; // length of next code
int count = 0; // repeat count of the current code
int max_count = 7; // max repeat count
int min_count = 4; // min repeat count
if (nextlen == 0){ max_count = 138; min_count = 3; }
for (n = 0; n <= max_code; n++) {
curlen = nextlen; nextlen = tree[(n+1)*2+1];
if(++count < max_count && curlen == nextlen) {
continue;
}
else if(count < min_count) {
do { send_code(curlen, bl_tree); } while (--count != 0);
}
else if(curlen != 0){
if(curlen != prevlen){
send_code(curlen, bl_tree); count--;
}
send_code(REP_3_6, bl_tree);
send_bits(count-3, 2);
}
else if(count <= 10){
send_code(REPZ_3_10, bl_tree);
send_bits(count-3, 3);
}
else{
send_code(REPZ_11_138, bl_tree);
send_bits(count-11, 7);
}
count = 0; prevlen = curlen;
if(nextlen == 0){
max_count = 138; min_count = 3;
}
else if(curlen == nextlen){
max_count = 6; min_count = 3;
}
else{
max_count = 7; min_count = 4;
}
}
}
// Output a byte on the stream.
// IN assertion: there is enough room in pending_buf.
final void put_byte(byte[] p, int start, int len){
System.arraycopy(p, start, pending_buf, pending, len);
pending+=len;
}
final void put_byte(byte c){
pending_buf[pending++]=c;
}
final void put_short(int w) {
put_byte((byte)(w/*&0xff*/));
put_byte((byte)(w>>>8));
}
final void putShortMSB(int b){
put_byte((byte)(b>>8));
put_byte((byte)(b/*&0xff*/));
}
final void send_code(int c, short[] tree){
int c2=c*2;
send_bits((tree[c2]&0xffff), (tree[c2+1]&0xffff));
}
void send_bits(int value, int length){
int len = length;
if (bi_valid > (int)Buf_size - len) {
int val = value;
// bi_buf |= (val << bi_valid);
bi_buf |= ((val << bi_valid)&0xffff);
put_short(bi_buf);
bi_buf = (short)(val >>> (Buf_size - bi_valid));
bi_valid += len - Buf_size;
} else {
// bi_buf |= (value) << bi_valid;
bi_buf |= (((value) << bi_valid)&0xffff);
bi_valid += len;
}
}
// Send one empty static block to give enough lookahead for inflate.
// This takes 10 bits, of which 7 may remain in the bit buffer.
// The current inflate code requires 9 bits of lookahead. If the
// last two codes for the previous block (real code plus EOB) were coded
// on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
// the last real code. In this case we send two empty static blocks instead
// of one. (There are no problems if the previous block is stored or fixed.)
// To simplify the code, we assume the worst case of last real code encoded
// on one bit only.
void _tr_align(){
send_bits(STATIC_TREES<<1, 3);
send_code(END_BLOCK, StaticTree.static_ltree);
bi_flush();
// Of the 10 bits for the empty block, we have already sent
// (10 - bi_valid) bits. The lookahead for the last real code (before
// the EOB of the previous block) was thus at least one plus the length
// of the EOB plus what we have just sent of the empty static block.
if (1 + last_eob_len + 10 - bi_valid < 9) {
send_bits(STATIC_TREES<<1, 3);
send_code(END_BLOCK, StaticTree.static_ltree);
bi_flush();
}
last_eob_len = 7;
}
// Save the match info and tally the frequency counts. Return true if
// the current block must be flushed.
boolean _tr_tally (int dist, // distance of matched string
int lc // match length-MIN_MATCH or unmatched char (if dist==0)
){
pending_buf[d_buf+last_lit*2] = (byte)(dist>>>8);
pending_buf[d_buf+last_lit*2+1] = (byte)dist;
pending_buf[l_buf+last_lit] = (byte)lc; last_lit++;
if (dist == 0) {
// lc is the unmatched char
dyn_ltree[lc*2]++;
}
else {
matches++;
// Here, lc is the match length - MIN_MATCH
dist--; // dist = match distance - 1
dyn_ltree[(Tree._length_code[lc]+LITERALS+1)*2]++;
dyn_dtree[Tree.d_code(dist)*2]++;
}
if ((last_lit & 0x1fff) == 0 && level > 2) {
// Compute an upper bound for the compressed length
int out_length = last_lit*8;
int in_length = strstart - block_start;
int dcode;
for (dcode = 0; dcode < D_CODES; dcode++) {
out_length += (int)dyn_dtree[dcode*2] *
(5L+Tree.extra_dbits[dcode]);
}
out_length >>>= 3;
if ((matches < (last_lit/2)) && out_length < in_length/2) return true;
}
return (last_lit == lit_bufsize-1);
// We avoid equality with lit_bufsize because of wraparound at 64K
// on 16 bit machines and because stored blocks are restricted to
// 64K-1 bytes.
}
// Send the block data compressed using the given Huffman trees
void compress_block(short[] ltree, short[] dtree){
int dist; // distance of matched string
int lc; // match length or unmatched char (if dist == 0)
int lx = 0; // running index in l_buf
int code; // the code to send
int extra; // number of extra bits to send
if (last_lit != 0){
do{
dist=((pending_buf[d_buf+lx*2]<<8)&0xff00)|
(pending_buf[d_buf+lx*2+1]&0xff);
lc=(pending_buf[l_buf+lx])&0xff; lx++;
if(dist == 0){
send_code(lc, ltree); // send a literal byte
}
else{
// Here, lc is the match length - MIN_MATCH
code = Tree._length_code[lc];
send_code(code+LITERALS+1, ltree); // send the length code
extra = Tree.extra_lbits[code];
if(extra != 0){
lc -= Tree.base_length[code];
send_bits(lc, extra); // send the extra length bits
}
dist--; // dist is now the match distance - 1
code = Tree.d_code(dist);
send_code(code, dtree); // send the distance code
extra = Tree.extra_dbits[code];
if (extra != 0) {
dist -= Tree.base_dist[code];
send_bits(dist, extra); // send the extra distance bits
}
} // literal or match pair ?
// Check that the overlay between pending_buf and d_buf+l_buf is ok:
}
while (lx < last_lit);
}
send_code(END_BLOCK, ltree);
last_eob_len = ltree[END_BLOCK*2+1];
}
// Set the data type to ASCII or BINARY, using a crude approximation:
// binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
// IN assertion: the fields freq of dyn_ltree are set and the total of all
// frequencies does not exceed 64K (to fit in an int on 16 bit machines).
void set_data_type(){
int n = 0;
int ascii_freq = 0;
int bin_freq = 0;
while(n<7){ bin_freq += dyn_ltree[n*2]; n++;}
while(n<128){ ascii_freq += dyn_ltree[n*2]; n++;}
while(n<LITERALS){ bin_freq += dyn_ltree[n*2]; n++;}
data_type=(byte)(bin_freq > (ascii_freq >>> 2) ? Z_BINARY : Z_ASCII);
}
// Flush the bit buffer, keeping at most 7 bits in it.
void bi_flush(){
if (bi_valid == 16) {
put_short(bi_buf);
bi_buf=0;
bi_valid=0;
}
else if (bi_valid >= 8) {
put_byte((byte)bi_buf);
bi_buf>>>=8;
bi_valid-=8;
}
}
// Flush the bit buffer and align the output on a byte boundary
void bi_windup(){
if (bi_valid > 8) {
put_short(bi_buf);
} else if (bi_valid > 0) {
put_byte((byte)bi_buf);
}
bi_buf = 0;
bi_valid = 0;
}
// Copy a stored block, storing first the length and its
// one's complement if requested.
void copy_block(int buf, // the input data
int len, // its length
boolean header // true if block header must be written
){
int index=0;
bi_windup(); // align on byte boundary
last_eob_len = 8; // enough lookahead for inflate
if (header) {
put_short((short)len);
put_short((short)~len);
}
// while(len--!=0) {
// put_byte(window[buf+index]);
// index++;
// }
put_byte(window, buf, len);
}
void flush_block_only(boolean eof){
_tr_flush_block(block_start>=0 ? block_start : -1,
strstart-block_start,
eof);
block_start=strstart;
strm.flush_pending();
}
// Copy without compression as much as possible from the input stream, return
// the current block state.
// This function does not insert new strings in the dictionary since
// uncompressible data is probably not useful. This function is used
// only for the level=0 compression option.
// NOTE: this function should be optimized to avoid extra copying from
// window to pending_buf.
int deflate_stored(int flush){
// Stored blocks are limited to 0xffff bytes, pending_buf is limited
// to pending_buf_size, and each stored block has a 5 byte header:
int max_block_size = 0xffff;
int max_start;
if(max_block_size > pending_buf_size - 5) {
max_block_size = pending_buf_size - 5;
}
// Copy as much as possible from input to output:
while(true){
// Fill the window as much as possible:
if(lookahead<=1){
fill_window();
if(lookahead==0 && flush==Z_NO_FLUSH) return NeedMore;
if(lookahead==0) break; // flush the current block
}
strstart+=lookahead;
lookahead=0;
// Emit a stored block if pending_buf will be full:
max_start=block_start+max_block_size;
if(strstart==0|| strstart>=max_start) {
// strstart == 0 is possible when wraparound on 16-bit machine
lookahead = (int)(strstart-max_start);
strstart = (int)max_start;
flush_block_only(false);
if(strm.avail_out==0) return NeedMore;
}
// Flush if we may have to slide, otherwise block_start may become
// negative and the data will be gone:
if(strstart-block_start >= w_size-MIN_LOOKAHEAD) {
flush_block_only(false);
if(strm.avail_out==0) return NeedMore;
}
}
flush_block_only(flush == Z_FINISH);
if(strm.avail_out==0)
return (flush == Z_FINISH) ? FinishStarted : NeedMore;
return flush == Z_FINISH ? FinishDone : BlockDone;
}
// Send a stored block
void _tr_stored_block(int buf, // input block
int stored_len, // length of input block
boolean eof // true if this is the last block for a file
){
send_bits((STORED_BLOCK<<1)+(eof?1:0), 3); // send block type
copy_block(buf, stored_len, true); // with header
}
// Determine the best encoding for the current block: dynamic trees, static
// trees or store, and output the encoded block to the zip file.
void _tr_flush_block(int buf, // input block, or NULL if too old
int stored_len, // length of input block
boolean eof // true if this is the last block for a file
) {
int opt_lenb, static_lenb;// opt_len and static_len in bytes
int max_blindex = 0; // index of last bit length code of non zero freq
// Build the Huffman trees unless a stored block is forced
if(level > 0) {
// Check if the file is ascii or binary
if(data_type == Z_UNKNOWN) set_data_type();
// Construct the literal and distance trees
l_desc.build_tree(this);
d_desc.build_tree(this);
// At this point, opt_len and static_len are the total bit lengths of
// the compressed block data, excluding the tree representations.
// Build the bit length tree for the above two trees, and get the index
// in bl_order of the last bit length code to send.
max_blindex=build_bl_tree();
// Determine the best encoding. Compute first the block length in bytes
opt_lenb=(opt_len+3+7)>>>3;
static_lenb=(static_len+3+7)>>>3;
if(static_lenb<=opt_lenb) opt_lenb=static_lenb;
}
else {
opt_lenb=static_lenb=stored_len+5; // force a stored block
}
if(stored_len+4<=opt_lenb && buf != -1){
// 4: two words for the lengths
// The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
// Otherwise we can't have processed more than WSIZE input bytes since
// the last block flush, because compression would have been
// successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
// transform a block into a stored block.
_tr_stored_block(buf, stored_len, eof);
}
else if(static_lenb == opt_lenb){
send_bits((STATIC_TREES<<1)+(eof?1:0), 3);
compress_block(StaticTree.static_ltree, StaticTree.static_dtree);
}
else{
send_bits((DYN_TREES<<1)+(eof?1:0), 3);
send_all_trees(l_desc.max_code+1, d_desc.max_code+1, max_blindex+1);
compress_block(dyn_ltree, dyn_dtree);
}
// The above check is made mod 2^32, for files larger than 512 MB
// and uLong implemented on 32 bits.
init_block();
if(eof){
bi_windup();
}
}
// Fill the window when the lookahead becomes insufficient.
// Updates strstart and lookahead.
//
// IN assertion: lookahead < MIN_LOOKAHEAD
// OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
// At least one byte has been read, or avail_in == 0; reads are
// performed for at least two bytes (required for the zip translate_eol
// option -- not supported here).
void fill_window(){
int n, m;
int p;
int more; // Amount of free space at the end of the window.
do{
more = (window_size-lookahead-strstart);
// Deal with !@#$% 64K limit:
if(more==0 && strstart==0 && lookahead==0){
more = w_size;
}
else if(more==-1) {
// Very unlikely, but possible on 16 bit machine if strstart == 0
// and lookahead == 1 (input done one byte at time)
more--;
// If the window is almost full and there is insufficient lookahead,
// move the upper half to the lower one to make room in the upper half.
}
else if(strstart >= w_size+ w_size-MIN_LOOKAHEAD) {
System.arraycopy(window, w_size, window, 0, w_size);
match_start-=w_size;
strstart-=w_size; // we now have strstart >= MAX_DIST
block_start-=w_size;
// Slide the hash table (could be avoided with 32 bit values
// at the expense of memory usage). We slide even when level == 0
// to keep the hash table consistent if we switch back to level > 0
// later. (Using level 0 permanently is not an optimal usage of
// zlib, so we don't care about this pathological case.)
n = hash_size;
p=n;
do {
m = (head[--p]&0xffff);
head[p]=(m>=w_size ? (short)(m-w_size) : 0);
}
while (--n != 0);
n = w_size;
p = n;
do {
m = (prev[--p]&0xffff);
prev[p] = (m >= w_size ? (short)(m-w_size) : 0);
// If n is not on any hash chain, prev[n] is garbage but
// its value will never be used.
}
while (--n!=0);
more += w_size;
}
if (strm.avail_in == 0) return;
// If there was no sliding:
// strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
// more == window_size - lookahead - strstart
// => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
// => more >= window_size - 2*WSIZE + 2
// In the BIG_MEM or MMAP case (not yet supported),
// window_size == input_size + MIN_LOOKAHEAD &&
// strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
// Otherwise, window_size == 2*WSIZE so more >= 2.
// If there was sliding, more >= WSIZE. So in all cases, more >= 2.
n = strm.read_buf(window, strstart + lookahead, more);
lookahead += n;
// Initialize the hash value now that we have some input:
if(lookahead >= MIN_MATCH) {
ins_h = window[strstart]&0xff;
ins_h=(((ins_h)<<hash_shift)^(window[strstart+1]&0xff))&hash_mask;
}
// If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
// but this is not important since only literal bytes will be emitted.
}
while (lookahead < MIN_LOOKAHEAD && strm.avail_in != 0);
}
// Compress as much as possible from the input stream, return the current
// block state.
// This function does not perform lazy evaluation of matches and inserts
// new strings in the dictionary only for unmatched strings or for short
// matches. It is used only for the fast compression options.
int deflate_fast(int flush){
// short hash_head = 0; // head of the hash chain
int hash_head = 0; // head of the hash chain
boolean bflush; // set if current block must be flushed
while(true){
// Make sure that we always have enough lookahead, except
// at the end of the input file. We need MAX_MATCH bytes
// for the next match, plus MIN_MATCH bytes to insert the
// string following the next match.
if(lookahead < MIN_LOOKAHEAD){
fill_window();
if(lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH){
return NeedMore;
}
if(lookahead == 0) break; // flush the current block
}
// Insert the string window[strstart .. strstart+2] in the
// dictionary, and set hash_head to the head of the hash chain:
if(lookahead >= MIN_MATCH){
ins_h=(((ins_h)<<hash_shift)^(window[(strstart)+(MIN_MATCH-1)]&0xff))&hash_mask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head=(head[ins_h]&0xffff);
prev[strstart&w_mask]=head[ins_h];
head[ins_h]=(short)strstart;
}
// Find the longest match, discarding those <= prev_length.
// At this point we have always match_length < MIN_MATCH
if(hash_head!=0L &&
((strstart-hash_head)&0xffff) <= w_size-MIN_LOOKAHEAD
){
// To simplify the code, we prevent matches with the string
// of window index 0 (in particular we have to avoid a match
// of the string with itself at the start of the input file).
if(strategy != Z_HUFFMAN_ONLY){
match_length=longest_match (hash_head);
}
// longest_match() sets match_start
}
if(match_length>=MIN_MATCH){
// check_match(strstart, match_start, match_length);
bflush=_tr_tally(strstart-match_start, match_length-MIN_MATCH);
lookahead -= match_length;
// Insert new strings in the hash table only if the match length
// is not too large. This saves time but degrades compression.
if(match_length <= max_lazy_match &&
lookahead >= MIN_MATCH) {
match_length--; // string at strstart already in hash table
do{
strstart++;
ins_h=((ins_h<<hash_shift)^(window[(strstart)+(MIN_MATCH-1)]&0xff))&hash_mask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head=(head[ins_h]&0xffff);
prev[strstart&w_mask]=head[ins_h];
head[ins_h]=(short)strstart;
// strstart never exceeds WSIZE-MAX_MATCH, so there are
// always MIN_MATCH bytes ahead.
}
while (--match_length != 0);
strstart++;
}
else{
strstart += match_length;
match_length = 0;
ins_h = window[strstart]&0xff;
ins_h=(((ins_h)<<hash_shift)^(window[strstart+1]&0xff))&hash_mask;
// If lookahead < MIN_MATCH, ins_h is garbage, but it does not
// matter since it will be recomputed at next deflate call.
}
}
else {
// No match, output a literal byte
bflush=_tr_tally(0, window[strstart]&0xff);
lookahead--;
strstart++;
}
if (bflush){
flush_block_only(false);
if(strm.avail_out==0) return NeedMore;
}
}
flush_block_only(flush == Z_FINISH);
if(strm.avail_out==0){
if(flush == Z_FINISH) return FinishStarted;
else return NeedMore;
}
return flush==Z_FINISH ? FinishDone : BlockDone;
}
// Same as above, but achieves better compression. We use a lazy
// evaluation for matches: a match is finally adopted only if there is
// no better match at the next window position.
int deflate_slow(int flush){
// short hash_head = 0; // head of hash chain
int hash_head = 0; // head of hash chain
boolean bflush; // set if current block must be flushed
// Process the input block.
while(true){
// Make sure that we always have enough lookahead, except
// at the end of the input file. We need MAX_MATCH bytes
// for the next match, plus MIN_MATCH bytes to insert the
// string following the next match.
if (lookahead < MIN_LOOKAHEAD) {
fill_window();
if(lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
return NeedMore;
}
if(lookahead == 0) break; // flush the current block
}
// Insert the string window[strstart .. strstart+2] in the
// dictionary, and set hash_head to the head of the hash chain:
if(lookahead >= MIN_MATCH) {
ins_h=(((ins_h)<<hash_shift)^(window[(strstart)+(MIN_MATCH-1)]&0xff)) & hash_mask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head=(head[ins_h]&0xffff);
prev[strstart&w_mask]=head[ins_h];
head[ins_h]=(short)strstart;
}
// Find the longest match, discarding those <= prev_length.
prev_length = match_length; prev_match = match_start;
match_length = MIN_MATCH-1;
if (hash_head != 0 && prev_length < max_lazy_match &&
((strstart-hash_head)&0xffff) <= w_size-MIN_LOOKAHEAD
){
// To simplify the code, we prevent matches with the string
// of window index 0 (in particular we have to avoid a match
// of the string with itself at the start of the input file).
if(strategy != Z_HUFFMAN_ONLY) {
match_length = longest_match(hash_head);
}
// longest_match() sets match_start
if (match_length <= 5 && (strategy == Z_FILTERED ||
(match_length == MIN_MATCH &&
strstart - match_start > 4096))) {
// If prev_match is also MIN_MATCH, match_start is garbage
// but we will ignore the current match anyway.
match_length = MIN_MATCH-1;
}
}
// If there was a match at the previous step and the current
// match is not better, output the previous match:
if(prev_length >= MIN_MATCH && match_length <= prev_length) {
int max_insert = strstart + lookahead - MIN_MATCH;
// Do not insert strings in hash table beyond this.
// check_match(strstart-1, prev_match, prev_length);
bflush=_tr_tally(strstart-1-prev_match, prev_length - MIN_MATCH);
// Insert in hash table all strings up to the end of the match.
// strstart-1 and strstart are already inserted. If there is not
// enough lookahead, the last two strings are not inserted in
// the hash table.
lookahead -= prev_length-1;
prev_length -= 2;
do{
if(++strstart <= max_insert) {
ins_h=(((ins_h)<<hash_shift)^(window[(strstart)+(MIN_MATCH-1)]&0xff))&hash_mask;
//prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head=(head[ins_h]&0xffff);
prev[strstart&w_mask]=head[ins_h];
head[ins_h]=(short)strstart;
}
}
while(--prev_length != 0);
match_available = 0;
match_length = MIN_MATCH-1;
strstart++;
if (bflush){
flush_block_only(false);
if(strm.avail_out==0) return NeedMore;
}
} else if (match_available!=0) {
// If there was no match at the previous position, output a
// single literal. If there was a match but the current match
// is longer, truncate the previous match to a single literal.
bflush=_tr_tally(0, window[strstart-1]&0xff);
if (bflush) {
flush_block_only(false);
}
strstart++;
lookahead--;
if(strm.avail_out == 0) return NeedMore;
} else {
// There is no previous match to compare with, wait for
// the next step to decide.
match_available = 1;
strstart++;
lookahead--;
}
}
if(match_available!=0) {
bflush=_tr_tally(0, window[strstart-1]&0xff);
match_available = 0;
}
flush_block_only(flush == Z_FINISH);
if(strm.avail_out==0){
if(flush == Z_FINISH) return FinishStarted;
else return NeedMore;
}
return flush == Z_FINISH ? FinishDone : BlockDone;
}
int longest_match(int cur_match){
int chain_length = max_chain_length; // max hash chain length
int scan = strstart; // current string
int match; // matched string
int len; // length of current match
int best_len = prev_length; // best match length so far
int limit = strstart>(w_size-MIN_LOOKAHEAD) ?
strstart-(w_size-MIN_LOOKAHEAD) : 0;
int nice_match=this.nice_match;
// Stop when cur_match becomes <= limit. To simplify the code,
// we prevent matches with the string of window index 0.
int wmask = w_mask;
int strend = strstart + MAX_MATCH;
byte scan_end1 = window[scan+best_len-1];
byte scan_end = window[scan+best_len];
// The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
// It is easy to get rid of this optimization if necessary.
// Do not waste too much time if we already have a good match:
if (prev_length >= good_match) {
chain_length >>= 2;
}
// Do not look for matches beyond the end of the input. This is necessary
// to make deflate deterministic.
if (nice_match > lookahead) nice_match = lookahead;
do {
match = cur_match;
// Skip to next match if the match length cannot increase
// or if the match length is less than 2:
if (window[match+best_len] != scan_end ||
window[match+best_len-1] != scan_end1 ||
window[match] != window[scan] ||
window[++match] != window[scan+1]) continue;
// The check at best_len-1 can be removed because it will be made
// again later. (This heuristic is not always a win.)
// It is not necessary to compare scan[2] and match[2] since they
// are always equal when the other bytes match, given that
// the hash keys are equal and that HASH_BITS >= 8.
scan += 2; match++;
// We check for insufficient lookahead only every 8th comparison;
// the 256th check will be made at strstart+258.
do {
} while (window[++scan] == window[++match] &&
window[++scan] == window[++match] &&
window[++scan] == window[++match] &&
window[++scan] == window[++match] &&
window[++scan] == window[++match] &&
window[++scan] == window[++match] &&
window[++scan] == window[++match] &&
window[++scan] == window[++match] &&
scan < strend);
len = MAX_MATCH - (int)(strend - scan);
scan = strend - MAX_MATCH;
if(len>best_len) {
match_start = cur_match;
best_len = len;
if (len >= nice_match) break;
scan_end1 = window[scan+best_len-1];
scan_end = window[scan+best_len];
}
} while ((cur_match = (prev[cur_match & wmask]&0xffff)) > limit
&& --chain_length != 0);
if (best_len <= lookahead) return best_len;
return lookahead;
}
int deflateInit(ZStream strm, int level, int bits){
return deflateInit2(strm, level, Z_DEFLATED, bits, DEF_MEM_LEVEL,
Z_DEFAULT_STRATEGY);
}
int deflateInit(ZStream strm, int level){
return deflateInit(strm, level, MAX_WBITS);
}
int deflateInit2(ZStream strm, int level, int method, int windowBits,
int memLevel, int strategy){
int noheader = 0;
// byte[] my_version=ZLIB_VERSION;
//
// if (version == null || version[0] != my_version[0]
// || stream_size != sizeof(z_stream)) {
// return Z_VERSION_ERROR;
// }
strm.msg = null;
if (level == Z_DEFAULT_COMPRESSION) level = 6;
if (windowBits < 0) { // undocumented feature: suppress zlib header
noheader = 1;
windowBits = -windowBits;
}
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL ||
method != Z_DEFLATED ||
windowBits < 9 || windowBits > 15 || level < 0 || level > 9 ||
strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
return Z_STREAM_ERROR;
}
strm.dstate = (Deflate)this;
this.noheader = noheader;
w_bits = windowBits;
w_size = 1 << w_bits;
w_mask = w_size - 1;
hash_bits = memLevel + 7;
hash_size = 1 << hash_bits;
hash_mask = hash_size - 1;
hash_shift = ((hash_bits+MIN_MATCH-1)/MIN_MATCH);
window = new byte[w_size*2];
prev = new short[w_size];
head = new short[hash_size];
lit_bufsize = 1 << (memLevel + 6); // 16K elements by default
// We overlay pending_buf and d_buf+l_buf. This works since the average
// output size for (length,distance) codes is <= 24 bits.
pending_buf = new byte[lit_bufsize*4];
pending_buf_size = lit_bufsize*4;
d_buf = lit_bufsize/2;
l_buf = (1+2)*lit_bufsize;
this.level = level;
//System.out.println("level="+level);
this.strategy = strategy;
this.method = (byte)method;
return deflateReset(strm);
}
int deflateReset(ZStream strm){
strm.total_in = strm.total_out = 0;
strm.msg = null; //
strm.data_type = Z_UNKNOWN;
pending = 0;
pending_out = 0;
if(noheader < 0) {
noheader = 0; // was set to -1 by deflate(..., Z_FINISH);
}
status = (noheader!=0) ? BUSY_STATE : INIT_STATE;
strm.adler=strm._adler.adler32(0, null, 0, 0);
last_flush = Z_NO_FLUSH;
tr_init();
lm_init();
return Z_OK;
}
int deflateEnd(){
if(status!=INIT_STATE && status!=BUSY_STATE && status!=FINISH_STATE){
return Z_STREAM_ERROR;
}
// Deallocate in reverse order of allocations:
pending_buf=null;
head=null;
prev=null;
window=null;
// free
// dstate=null;
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
}
int deflateParams(ZStream strm, int _level, int _strategy){
int err=Z_OK;
if(_level == Z_DEFAULT_COMPRESSION){
_level = 6;
}
if(_level < 0 || _level > 9 ||
_strategy < 0 || _strategy > Z_HUFFMAN_ONLY) {
return Z_STREAM_ERROR;
}
if(config_table[level].func!=config_table[_level].func &&
strm.total_in != 0) {
// Flush the last buffer:
err = strm.deflate(Z_PARTIAL_FLUSH);
}
if(level != _level) {
level = _level;
max_lazy_match = config_table[level].max_lazy;
good_match = config_table[level].good_length;
nice_match = config_table[level].nice_length;
max_chain_length = config_table[level].max_chain;
}
strategy = _strategy;
return err;
}
int deflateSetDictionary (ZStream strm, byte[] dictionary, int dictLength){
int length = dictLength;
int index=0;
if(dictionary == null || status != INIT_STATE)
return Z_STREAM_ERROR;
strm.adler=strm._adler.adler32(strm.adler, dictionary, 0, dictLength);
if(length < MIN_MATCH) return Z_OK;
if(length > w_size-MIN_LOOKAHEAD){
length = w_size-MIN_LOOKAHEAD;
index=dictLength-length; // use the tail of the dictionary
}
System.arraycopy(dictionary, index, window, 0, length);
strstart = length;
block_start = length;
// Insert all strings in the hash table (except for the last two bytes).
// s->lookahead stays null, so s->ins_h will be recomputed at the next
// call of fill_window.
ins_h = window[0]&0xff;
ins_h=(((ins_h)<<hash_shift)^(window[1]&0xff))&hash_mask;
for(int n=0; n<=length-MIN_MATCH; n++){
ins_h=(((ins_h)<<hash_shift)^(window[(n)+(MIN_MATCH-1)]&0xff))&hash_mask;
prev[n&w_mask]=head[ins_h];
head[ins_h]=(short)n;
}
return Z_OK;
}
int deflate(ZStream strm, int flush){
int old_flush;
if(flush>Z_FINISH || flush<0){
return Z_STREAM_ERROR;
}
if(strm.next_out == null ||
(strm.next_in == null && strm.avail_in != 0) ||
(status == FINISH_STATE && flush != Z_FINISH)) {
strm.msg=z_errmsg[Z_NEED_DICT-(Z_STREAM_ERROR)];
return Z_STREAM_ERROR;
}
if(strm.avail_out == 0){
strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)];
return Z_BUF_ERROR;
}
this.strm = strm; // just in case
old_flush = last_flush;
last_flush = flush;
// Write the zlib header
if(status == INIT_STATE) {
int header = (Z_DEFLATED+((w_bits-8)<<4))<<8;
int level_flags=((level-1)&0xff)>>1;
if(level_flags>3) level_flags=3;
header |= (level_flags<<6);
if(strstart!=0) header |= PRESET_DICT;
header+=31-(header % 31);
status=BUSY_STATE;
putShortMSB(header);
// Save the adler32 of the preset dictionary:
if(strstart!=0){
putShortMSB((int)(strm.adler>>>16));
putShortMSB((int)(strm.adler&0xffff));
}
strm.adler=strm._adler.adler32(0, null, 0, 0);
}
// Flush as much pending output as possible
if(pending != 0) {
strm.flush_pending();
if(strm.avail_out == 0) {
//System.out.println(" avail_out==0");
// Since avail_out is 0, deflate will be called again with
// more output space, but possibly with both pending and
// avail_in equal to zero. There won't be anything to do,
// but this is not an error situation so make sure we
// return OK instead of BUF_ERROR at next call of deflate:
last_flush = -1;
return Z_OK;
}
// Make sure there is something to do and avoid duplicate consecutive
// flushes. For repeated and useless calls with Z_FINISH, we keep
// returning Z_STREAM_END instead of Z_BUFF_ERROR.
}
else if(strm.avail_in==0 && flush <= old_flush &&
flush != Z_FINISH) {
strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)];
return Z_BUF_ERROR;
}
// User must not provide more input after the first FINISH:
if(status == FINISH_STATE && strm.avail_in != 0) {
strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)];
return Z_BUF_ERROR;
}
// Start a new block or continue the current one.
if(strm.avail_in!=0 || lookahead!=0 ||
(flush != Z_NO_FLUSH && status != FINISH_STATE)) {
int bstate=-1;
switch(config_table[level].func){
case STORED:
bstate = deflate_stored(flush);
break;
case FAST:
bstate = deflate_fast(flush);
break;
case SLOW:
bstate = deflate_slow(flush);
break;
default:
}
if (bstate==FinishStarted || bstate==FinishDone) {
status = FINISH_STATE;
}
if (bstate==NeedMore || bstate==FinishStarted) {
if(strm.avail_out == 0) {
last_flush = -1; // avoid BUF_ERROR next call, see above
}
return Z_OK;
// If flush != Z_NO_FLUSH && avail_out == 0, the next call
// of deflate should use the same flush parameter to make sure
// that the flush is complete. So we don't have to output an
// empty block here, this will be done at next call. This also
// ensures that for a very small output buffer, we emit at most
// one empty block.
}
if (bstate==BlockDone) {
if(flush == Z_PARTIAL_FLUSH) {
_tr_align();
}
else { // FULL_FLUSH or SYNC_FLUSH
_tr_stored_block(0, 0, false);
// For a full flush, this empty block will be recognized
// as a special marker by inflate_sync().
if(flush == Z_FULL_FLUSH) {
//state.head[s.hash_size-1]=0;
for(int i=0; i<hash_size/*-1*/; i++) // forget history
head[i]=0;
}
}
strm.flush_pending();
if(strm.avail_out == 0) {
last_flush = -1; // avoid BUF_ERROR at next call, see above
return Z_OK;
}
}
}
if(flush!=Z_FINISH) return Z_OK;
if(noheader!=0) return Z_STREAM_END;
// Write the zlib trailer (adler32)
putShortMSB((int)(strm.adler>>>16));
putShortMSB((int)(strm.adler&0xffff));
strm.flush_pending();
// If avail_out is zero, the application will call deflate again
// to flush the rest.
noheader = -1; // write the trailer only once!
return pending != 0 ? Z_OK : Z_STREAM_END;
}
}
| Java |
/*
* This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
*
* (c) Matthias L. Jugel, Marcus Meiner 1996-2005. All Rights Reserved.
*
* Please visit http://javatelnet.org/ for updates and contact.
*
* --LICENSE NOTICE--
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* --LICENSE NOTICE--
*
*/
package de.mud.terminal;
import android.text.AndroidCharacter;
import java.util.Properties;
/**
* Implementation of a VT terminal emulation plus ANSI compatible.
* <P>
* <B>Maintainer:</B> Marcus Meißner
*
* @version $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
* @author Matthias L. Jugel, Marcus Meißner
*/
public abstract class vt320 extends VDUBuffer implements VDUInput {
/** The current version id tag.<P>
* $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
*
*/
public final static String ID = "$Id: vt320.java 507 2005-10-25 10:14:52Z marcus $";
/** the debug level */
private final static int debug = 0;
private StringBuilder debugStr;
public abstract void debug(String notice);
/**
* Write an answer back to the remote host. This is needed to be able to
* send terminal answers requests like status and type information.
* @param b the array of bytes to be sent
*/
public abstract void write(byte[] b);
/**
* Write an answer back to the remote host. This is needed to be able to
* send terminal answers requests like status and type information.
* @param b the array of bytes to be sent
*/
public abstract void write(int b);
/**
* Play the beep sound ...
*/
public void beep() { /* do nothing by default */
}
/**
* Convenience function for putString(char[], int, int)
*/
public void putString(String s) {
int len = s.length();
char[] tmp = new char[len];
s.getChars(0, len, tmp, 0);
putString(tmp, null, 0, len);
}
/**
* Put string at current cursor position. Moves cursor
* according to the String. Does NOT wrap.
* @param s character array
* @param start place to start in array
* @param len number of characters to process
*/
public void putString(char[] s, byte[] fullwidths, int start, int len) {
if (len > 0) {
//markLine(R, 1);
int lastChar = -1;
char c;
boolean isWide = false;
for (int i = 0; i < len; i++) {
c = s[start + i];
// Shortcut for my favorite ASCII
if (c <= 0x7F) {
if (lastChar != -1)
putChar((char) lastChar, isWide, false);
lastChar = c;
isWide = false;
} else if (!Character.isLowSurrogate(c) && !Character.isHighSurrogate(c)) {
if (Character.getType(c) == Character.NON_SPACING_MARK) {
if (lastChar != -1) {
char nc = Precomposer.precompose((char) lastChar, c);
putChar(nc, isWide, false);
lastChar = -1;
}
} else {
if (lastChar != -1)
putChar((char) lastChar, isWide, false);
lastChar = c;
if (fullwidths != null) {
final byte width = fullwidths[i];
isWide = (width == AndroidCharacter.EAST_ASIAN_WIDTH_WIDE)
|| (width == AndroidCharacter.EAST_ASIAN_WIDTH_FULL_WIDTH);
}
}
}
}
if (lastChar != -1)
putChar((char) lastChar, isWide, false);
setCursorPosition(C, R);
redraw();
}
}
protected void sendTelnetCommand(byte cmd) {
}
/**
* Sent the changed window size from the terminal to all listeners.
*/
protected void setWindowSize(int c, int r) {
/* To be overridden by Terminal.java */
}
@Override
public void setScreenSize(int c, int r, boolean broadcast) {
int oldrows = height;
if (debug>2) {
if (debugStr == null)
debugStr = new StringBuilder();
debugStr.append("setscreensize (")
.append(c)
.append(',')
.append(r)
.append(',')
.append(broadcast)
.append(')');
debug(debugStr.toString());
debugStr.setLength(0);
}
super.setScreenSize(c,r,false);
boolean cursorChanged = false;
// Don't let the cursor go off the screen.
if (C >= c) {
C = c - 1;
cursorChanged = true;
}
if (R >= r) {
R = r - 1;
cursorChanged = true;
}
if (cursorChanged) {
setCursorPosition(C, R);
redraw();
}
if (broadcast) {
setWindowSize(c, r); /* broadcast up */
}
}
/**
* Create a new vt320 terminal and intialize it with useful settings.
*/
public vt320(int width, int height) {
super(width, height);
debugStr = new StringBuilder();
setVMS(false);
setIBMCharset(false);
setTerminalID("vt320");
setBufferSize(100);
//setBorder(2, false);
gx = new char[4];
reset();
/* top row of numpad */
PF1 = "\u001bOP";
PF2 = "\u001bOQ";
PF3 = "\u001bOR";
PF4 = "\u001bOS";
/* the 3x2 keyblock on PC keyboards */
Insert = new String[4];
Remove = new String[4];
KeyHome = new String[4];
KeyEnd = new String[4];
NextScn = new String[4];
PrevScn = new String[4];
Escape = new String[4];
BackSpace = new String[4];
TabKey = new String[4];
Insert[0] = Insert[1] = Insert[2] = Insert[3] = "\u001b[2~";
Remove[0] = Remove[1] = Remove[2] = Remove[3] = "\u001b[3~";
PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[5~";
NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[6~";
KeyHome[0] = KeyHome[1] = KeyHome[2] = KeyHome[3] = "\u001b[H";
KeyEnd[0] = KeyEnd[1] = KeyEnd[2] = KeyEnd[3] = "\u001b[F";
Escape[0] = Escape[1] = Escape[2] = Escape[3] = "\u001b";
if (vms) {
BackSpace[1] = "" + (char) 10; // VMS shift deletes word back
BackSpace[2] = "\u0018"; // VMS control deletes line back
BackSpace[0] = BackSpace[3] = "\u007f"; // VMS other is delete
} else {
//BackSpace[0] = BackSpace[1] = BackSpace[2] = BackSpace[3] = "\b";
// ConnectBot modifications.
BackSpace[0] = "\b";
BackSpace[1] = "\u007f";
BackSpace[2] = "\u001b[3~";
BackSpace[3] = "\u001b[2~";
}
/* some more VT100 keys */
Find = "\u001b[1~";
Select = "\u001b[4~";
Help = "\u001b[28~";
Do = "\u001b[29~";
FunctionKey = new String[21];
FunctionKey[0] = "";
FunctionKey[1] = PF1;
FunctionKey[2] = PF2;
FunctionKey[3] = PF3;
FunctionKey[4] = PF4;
/* following are defined differently for vt220 / vt132 ... */
FunctionKey[5] = "\u001b[15~";
FunctionKey[6] = "\u001b[17~";
FunctionKey[7] = "\u001b[18~";
FunctionKey[8] = "\u001b[19~";
FunctionKey[9] = "\u001b[20~";
FunctionKey[10] = "\u001b[21~";
FunctionKey[11] = "\u001b[23~";
FunctionKey[12] = "\u001b[24~";
FunctionKey[13] = "\u001b[25~";
FunctionKey[14] = "\u001b[26~";
FunctionKey[15] = Help;
FunctionKey[16] = Do;
FunctionKey[17] = "\u001b[31~";
FunctionKey[18] = "\u001b[32~";
FunctionKey[19] = "\u001b[33~";
FunctionKey[20] = "\u001b[34~";
FunctionKeyShift = new String[21];
FunctionKeyAlt = new String[21];
FunctionKeyCtrl = new String[21];
for (int i = 0; i < 20; i++) {
FunctionKeyShift[i] = "";
FunctionKeyAlt[i] = "";
FunctionKeyCtrl[i] = "";
}
FunctionKeyShift[15] = Find;
FunctionKeyShift[16] = Select;
TabKey[0] = "\u0009";
TabKey[1] = "\u001bOP\u0009";
TabKey[2] = TabKey[3] = "";
KeyUp = new String[4];
KeyUp[0] = "\u001b[A";
KeyDown = new String[4];
KeyDown[0] = "\u001b[B";
KeyRight = new String[4];
KeyRight[0] = "\u001b[C";
KeyLeft = new String[4];
KeyLeft[0] = "\u001b[D";
Numpad = new String[10];
Numpad[0] = "\u001bOp";
Numpad[1] = "\u001bOq";
Numpad[2] = "\u001bOr";
Numpad[3] = "\u001bOs";
Numpad[4] = "\u001bOt";
Numpad[5] = "\u001bOu";
Numpad[6] = "\u001bOv";
Numpad[7] = "\u001bOw";
Numpad[8] = "\u001bOx";
Numpad[9] = "\u001bOy";
KPMinus = PF4;
KPComma = "\u001bOl";
KPPeriod = "\u001bOn";
KPEnter = "\u001bOM";
NUMPlus = new String[4];
NUMPlus[0] = "+";
NUMDot = new String[4];
NUMDot[0] = ".";
}
public void setBackspace(int type) {
switch (type) {
case DELETE_IS_DEL:
BackSpace[0] = "\u007f";
BackSpace[1] = "\b";
break;
case DELETE_IS_BACKSPACE:
BackSpace[0] = "\b";
BackSpace[1] = "\u007f";
break;
}
}
/**
* Create a default vt320 terminal with 80 columns and 24 lines.
*/
public vt320() {
this(80, 24);
}
/**
* Terminal is mouse-aware and requires (x,y) coordinates of
* on the terminal (character coordinates) and the button clicked.
* @param x
* @param y
* @param modifiers
*/
public void mousePressed(int x, int y, int modifiers) {
if (mouserpt == 0)
return;
int mods = modifiers;
mousebut = 3;
if ((mods & 16) == 16) mousebut = 0;
if ((mods & 8) == 8) mousebut = 1;
if ((mods & 4) == 4) mousebut = 2;
int mousecode;
if (mouserpt == 9) /* X10 Mouse */
mousecode = 0x20 | mousebut;
else /* normal xterm mouse reporting */
mousecode = mousebut | 0x20 | ((mods & 7) << 2);
byte b[] = new byte[6];
b[0] = 27;
b[1] = (byte) '[';
b[2] = (byte) 'M';
b[3] = (byte) mousecode;
b[4] = (byte) (0x20 + x + 1);
b[5] = (byte) (0x20 + y + 1);
write(b); // FIXME: writeSpecial here
}
/**
* Terminal is mouse-aware and requires the coordinates and button
* of the release.
* @param x
* @param y
* @param modifiers
*/
public void mouseReleased(int x, int y, int modifiers) {
if (mouserpt == 0)
return;
/* problem is tht modifiers still have the released button set in them.
int mods = modifiers;
mousebut = 3;
if ((mods & 16)==16) mousebut=0;
if ((mods & 8)==8 ) mousebut=1;
if ((mods & 4)==4 ) mousebut=2;
*/
int mousecode;
if (mouserpt == 9)
mousecode = 0x20 + mousebut; /* same as press? appears so. */
else
mousecode = '#';
byte b[] = new byte[6];
b[0] = 27;
b[1] = (byte) '[';
b[2] = (byte) 'M';
b[3] = (byte) mousecode;
b[4] = (byte) (0x20 + x + 1);
b[5] = (byte) (0x20 + y + 1);
write(b); // FIXME: writeSpecial here
mousebut = 0;
}
/** we should do localecho (passed from other modules). false is default */
private boolean localecho = false;
/**
* Enable or disable the local echo property of the terminal.
* @param echo true if the terminal should echo locally
*/
public void setLocalEcho(boolean echo) {
localecho = echo;
}
/**
* Enable the VMS mode of the terminal to handle some things differently
* for VMS hosts.
* @param vms true for vms mode, false for normal mode
*/
public void setVMS(boolean vms) {
this.vms = vms;
}
/**
* Enable the usage of the IBM character set used by some BBS's. Special
* graphical character are available in this mode.
* @param ibm true to use the ibm character set
*/
public void setIBMCharset(boolean ibm) {
useibmcharset = ibm;
}
/**
* Override the standard key codes used by the terminal emulation.
* @param codes a properties object containing key code definitions
*/
public void setKeyCodes(Properties codes) {
String res, prefixes[] = {"", "S", "C", "A"};
int i;
for (i = 0; i < 10; i++) {
res = codes.getProperty("NUMPAD" + i);
if (res != null) Numpad[i] = unEscape(res);
}
for (i = 1; i < 20; i++) {
res = codes.getProperty("F" + i);
if (res != null) FunctionKey[i] = unEscape(res);
res = codes.getProperty("SF" + i);
if (res != null) FunctionKeyShift[i] = unEscape(res);
res = codes.getProperty("CF" + i);
if (res != null) FunctionKeyCtrl[i] = unEscape(res);
res = codes.getProperty("AF" + i);
if (res != null) FunctionKeyAlt[i] = unEscape(res);
}
for (i = 0; i < 4; i++) {
res = codes.getProperty(prefixes[i] + "PGUP");
if (res != null) PrevScn[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "PGDOWN");
if (res != null) NextScn[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "END");
if (res != null) KeyEnd[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "HOME");
if (res != null) KeyHome[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "INSERT");
if (res != null) Insert[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "REMOVE");
if (res != null) Remove[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "UP");
if (res != null) KeyUp[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "DOWN");
if (res != null) KeyDown[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "LEFT");
if (res != null) KeyLeft[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "RIGHT");
if (res != null) KeyRight[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "ESCAPE");
if (res != null) Escape[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "BACKSPACE");
if (res != null) BackSpace[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "TAB");
if (res != null) TabKey[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "NUMPLUS");
if (res != null) NUMPlus[i] = unEscape(res);
res = codes.getProperty(prefixes[i] + "NUMDECIMAL");
if (res != null) NUMDot[i] = unEscape(res);
}
}
/**
* Set the terminal id used to identify this terminal.
* @param terminalID the id string
*/
public void setTerminalID(String terminalID) {
this.terminalID = terminalID;
if (terminalID.equals("scoansi")) {
FunctionKey[1] = "\u001b[M"; FunctionKey[2] = "\u001b[N";
FunctionKey[3] = "\u001b[O"; FunctionKey[4] = "\u001b[P";
FunctionKey[5] = "\u001b[Q"; FunctionKey[6] = "\u001b[R";
FunctionKey[7] = "\u001b[S"; FunctionKey[8] = "\u001b[T";
FunctionKey[9] = "\u001b[U"; FunctionKey[10] = "\u001b[V";
FunctionKey[11] = "\u001b[W"; FunctionKey[12] = "\u001b[X";
FunctionKey[13] = "\u001b[Y"; FunctionKey[14] = "?";
FunctionKey[15] = "\u001b[a"; FunctionKey[16] = "\u001b[b";
FunctionKey[17] = "\u001b[c"; FunctionKey[18] = "\u001b[d";
FunctionKey[19] = "\u001b[e"; FunctionKey[20] = "\u001b[f";
PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[I";
NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[G";
// more theoretically.
}
}
public void setAnswerBack(String ab) {
this.answerBack = unEscape(ab);
}
/**
* Get the terminal id used to identify this terminal.
*/
public String getTerminalID() {
return terminalID;
}
/**
* A small conveniance method thar converts the string to a byte array
* for sending.
* @param s the string to be sent
*/
private boolean write(String s, boolean doecho) {
if (debug > 2) {
debugStr.append("write(|")
.append(s)
.append("|,")
.append(doecho);
debug(debugStr.toString());
debugStr.setLength(0);
}
if (s == null) // aka the empty string.
return true;
/* NOTE: getBytes() honours some locale, it *CONVERTS* the string.
* However, we output only 7bit stuff towards the target, and *some*
* 8 bit control codes. We must not mess up the latter, so we do hand
* by hand copy.
*/
byte arr[] = new byte[s.length()];
for (int i = 0; i < s.length(); i++) {
arr[i] = (byte) s.charAt(i);
}
write(arr);
if (doecho)
putString(s);
return true;
}
private boolean write(int s, boolean doecho) {
if (debug > 2) {
debugStr.append("write(|")
.append(s)
.append("|,")
.append(doecho);
debug(debugStr.toString());
debugStr.setLength(0);
}
write(s);
// TODO check if character is wide
if (doecho)
putChar((char)s, false, false);
return true;
}
private boolean write(String s) {
return write(s, localecho);
}
// ===================================================================
// the actual terminal emulation code comes here:
// ===================================================================
private String terminalID = "vt320";
private String answerBack = "Use Terminal.answerback to set ...\n";
// X - COLUMNS, Y - ROWS
int R,C;
int attributes = 0;
int Sc,Sr,Sa,Stm,Sbm;
char Sgr,Sgl;
char Sgx[];
int insertmode = 0;
int statusmode = 0;
boolean vt52mode = false;
boolean keypadmode = false; /* false - numeric, true - application */
boolean output8bit = false;
int normalcursor = 0;
boolean moveoutsidemargins = true;
boolean wraparound = true;
boolean sendcrlf = true;
boolean capslock = false;
boolean numlock = false;
int mouserpt = 0;
byte mousebut = 0;
boolean useibmcharset = false;
int lastwaslf = 0;
boolean usedcharsets = false;
private final static char ESC = 27;
private final static char IND = 132;
private final static char NEL = 133;
private final static char RI = 141;
private final static char SS2 = 142;
private final static char SS3 = 143;
private final static char DCS = 144;
private final static char HTS = 136;
private final static char CSI = 155;
private final static char OSC = 157;
private final static int TSTATE_DATA = 0;
private final static int TSTATE_ESC = 1; /* ESC */
private final static int TSTATE_CSI = 2; /* ESC [ */
private final static int TSTATE_DCS = 3; /* ESC P */
private final static int TSTATE_DCEQ = 4; /* ESC [? */
private final static int TSTATE_ESCSQUARE = 5; /* ESC # */
private final static int TSTATE_OSC = 6; /* ESC ] */
private final static int TSTATE_SETG0 = 7; /* ESC (? */
private final static int TSTATE_SETG1 = 8; /* ESC )? */
private final static int TSTATE_SETG2 = 9; /* ESC *? */
private final static int TSTATE_SETG3 = 10; /* ESC +? */
private final static int TSTATE_CSI_DOLLAR = 11; /* ESC [ Pn $ */
private final static int TSTATE_CSI_EX = 12; /* ESC [ ! */
private final static int TSTATE_ESCSPACE = 13; /* ESC <space> */
private final static int TSTATE_VT52X = 14;
private final static int TSTATE_VT52Y = 15;
private final static int TSTATE_CSI_TICKS = 16;
private final static int TSTATE_CSI_EQUAL = 17; /* ESC [ = */
private final static int TSTATE_TITLE = 18; /* xterm title */
/* Keys we support */
public final static int KEY_PAUSE = 1;
public final static int KEY_F1 = 2;
public final static int KEY_F2 = 3;
public final static int KEY_F3 = 4;
public final static int KEY_F4 = 5;
public final static int KEY_F5 = 6;
public final static int KEY_F6 = 7;
public final static int KEY_F7 = 8;
public final static int KEY_F8 = 9;
public final static int KEY_F9 = 10;
public final static int KEY_F10 = 11;
public final static int KEY_F11 = 12;
public final static int KEY_F12 = 13;
public final static int KEY_UP = 14;
public final static int KEY_DOWN =15 ;
public final static int KEY_LEFT = 16;
public final static int KEY_RIGHT = 17;
public final static int KEY_PAGE_DOWN = 18;
public final static int KEY_PAGE_UP = 19;
public final static int KEY_INSERT = 20;
public final static int KEY_DELETE = 21;
public final static int KEY_BACK_SPACE = 22;
public final static int KEY_HOME = 23;
public final static int KEY_END = 24;
public final static int KEY_NUM_LOCK = 25;
public final static int KEY_CAPS_LOCK = 26;
public final static int KEY_SHIFT = 27;
public final static int KEY_CONTROL = 28;
public final static int KEY_ALT = 29;
public final static int KEY_ENTER = 30;
public final static int KEY_NUMPAD0 = 31;
public final static int KEY_NUMPAD1 = 32;
public final static int KEY_NUMPAD2 = 33;
public final static int KEY_NUMPAD3 = 34;
public final static int KEY_NUMPAD4 = 35;
public final static int KEY_NUMPAD5 = 36;
public final static int KEY_NUMPAD6 = 37;
public final static int KEY_NUMPAD7 = 38;
public final static int KEY_NUMPAD8 = 39;
public final static int KEY_NUMPAD9 = 40;
public final static int KEY_DECIMAL = 41;
public final static int KEY_ADD = 42;
public final static int KEY_ESCAPE = 43;
public final static int DELETE_IS_DEL = 0;
public final static int DELETE_IS_BACKSPACE = 1;
/* The graphics charsets
* B - default ASCII
* A - ISO Latin 1
* 0 - DEC SPECIAL
* < - User defined
* ....
*/
char gx[];
char gl; // GL (left charset)
char gr; // GR (right charset)
int onegl; // single shift override for GL.
// Map from scoansi linedrawing to DEC _and_ unicode (for the stuff which
// is not in linedrawing). Got from experimenting with scoadmin.
private final static String scoansi_acs = "Tm7k3x4u?kZl@mYjEnB\u2566DqCtAvM\u2550:\u2551N\u2557I\u2554;\u2557H\u255a0a<\u255d";
// array to store DEC Special -> Unicode mapping
// Unicode DEC Unicode name (DEC name)
private static char DECSPECIAL[] = {
'\u0040', //5f blank
'\u2666', //60 black diamond
'\u2592', //61 grey square
'\u2409', //62 Horizontal tab (ht) pict. for control
'\u240c', //63 Form Feed (ff) pict. for control
'\u240d', //64 Carriage Return (cr) pict. for control
'\u240a', //65 Line Feed (lf) pict. for control
'\u00ba', //66 Masculine ordinal indicator
'\u00b1', //67 Plus or minus sign
'\u2424', //68 New Line (nl) pict. for control
'\u240b', //69 Vertical Tab (vt) pict. for control
'\u2518', //6a Forms light up and left
'\u2510', //6b Forms light down and left
'\u250c', //6c Forms light down and right
'\u2514', //6d Forms light up and right
'\u253c', //6e Forms light vertical and horizontal
'\u2594', //6f Upper 1/8 block (Scan 1)
'\u2580', //70 Upper 1/2 block (Scan 3)
'\u2500', //71 Forms light horizontal or ?em dash? (Scan 5)
'\u25ac', //72 \u25ac black rect. or \u2582 lower 1/4 (Scan 7)
'\u005f', //73 \u005f underscore or \u2581 lower 1/8 (Scan 9)
'\u251c', //74 Forms light vertical and right
'\u2524', //75 Forms light vertical and left
'\u2534', //76 Forms light up and horizontal
'\u252c', //77 Forms light down and horizontal
'\u2502', //78 vertical bar
'\u2264', //79 less than or equal
'\u2265', //7a greater than or equal
'\u00b6', //7b paragraph
'\u2260', //7c not equal
'\u00a3', //7d Pound Sign (british)
'\u00b7' //7e Middle Dot
};
/** Strings to send on function key pressing */
private String Numpad[];
private String FunctionKey[];
private String FunctionKeyShift[];
private String FunctionKeyCtrl[];
private String FunctionKeyAlt[];
private String TabKey[];
private String KeyUp[],KeyDown[],KeyLeft[],KeyRight[];
private String KPMinus, KPComma, KPPeriod, KPEnter;
private String PF1, PF2, PF3, PF4;
private String Help, Do, Find, Select;
private String KeyHome[], KeyEnd[], Insert[], Remove[], PrevScn[], NextScn[];
private String Escape[], BackSpace[], NUMDot[], NUMPlus[];
private String osc,dcs; /* to memorize OSC & DCS control sequence */
/** vt320 state variable (internal) */
private int term_state = TSTATE_DATA;
/** in vms mode, set by Terminal.VMS property */
private boolean vms = false;
/** Tabulators */
private byte[] Tabs;
/** The list of integers as used by CSI */
private int[] DCEvars = new int[30];
private int DCEvar;
/**
* Replace escape code characters (backslash + identifier) with their
* respective codes.
* @param tmp the string to be parsed
* @return a unescaped string
*/
static String unEscape(String tmp) {
int idx = 0, oldidx = 0;
String cmd;
// f.println("unescape("+tmp+")");
cmd = "";
while ((idx = tmp.indexOf('\\', oldidx)) >= 0 &&
++idx <= tmp.length()) {
cmd += tmp.substring(oldidx, idx - 1);
if (idx == tmp.length()) return cmd;
switch (tmp.charAt(idx)) {
case 'b':
cmd += "\b";
break;
case 'e':
cmd += "\u001b";
break;
case 'n':
cmd += "\n";
break;
case 'r':
cmd += "\r";
break;
case 't':
cmd += "\t";
break;
case 'v':
cmd += "\u000b";
break;
case 'a':
cmd += "\u0012";
break;
default :
if ((tmp.charAt(idx) >= '0') && (tmp.charAt(idx) <= '9')) {
int i;
for (i = idx; i < tmp.length(); i++)
if ((tmp.charAt(i) < '0') || (tmp.charAt(i) > '9'))
break;
cmd += (char) Integer.parseInt(tmp.substring(idx, i));
idx = i - 1;
} else
cmd += tmp.substring(idx, ++idx);
break;
}
oldidx = ++idx;
}
if (oldidx <= tmp.length()) cmd += tmp.substring(oldidx);
return cmd;
}
/**
* A small conveniance method thar converts a 7bit string to the 8bit
* version depending on VT52/Output8Bit mode.
*
* @param s the string to be sent
*/
private boolean writeSpecial(String s) {
if (s == null)
return true;
if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == 'O'))) {
if (vt52mode) {
if ((s.charAt(2) >= 'P') && (s.charAt(2) <= 'S')) {
s = "\u001b" + s.substring(2); /* ESC x */
} else {
s = "\u001b?" + s.substring(2); /* ESC ? x */
}
} else {
if (output8bit) {
s = "\u008f" + s.substring(2); /* SS3 x */
} /* else keep string as it is */
}
}
if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == '['))) {
if (output8bit) {
s = "\u009b" + s.substring(2); /* CSI ... */
} /* else keep */
}
return write(s, false);
}
/**
* main keytyping event handler...
*/
public void keyPressed(int keyCode, char keyChar, int modifiers) {
boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
if (debug > 1) {
debugStr.append("keyPressed(")
.append(keyCode)
.append(", ")
.append((int)keyChar)
.append(", ")
.append(modifiers)
.append(')');
debug(debugStr.toString());
debugStr.setLength(0);
}
int xind;
String fmap[];
xind = 0;
fmap = FunctionKey;
if (shift) {
fmap = FunctionKeyShift;
xind = 1;
}
if (control) {
fmap = FunctionKeyCtrl;
xind = 2;
}
if (alt) {
fmap = FunctionKeyAlt;
xind = 3;
}
switch (keyCode) {
case KEY_PAUSE:
if (shift || control)
sendTelnetCommand((byte) 243); // BREAK
break;
case KEY_F1:
writeSpecial(fmap[1]);
break;
case KEY_F2:
writeSpecial(fmap[2]);
break;
case KEY_F3:
writeSpecial(fmap[3]);
break;
case KEY_F4:
writeSpecial(fmap[4]);
break;
case KEY_F5:
writeSpecial(fmap[5]);
break;
case KEY_F6:
writeSpecial(fmap[6]);
break;
case KEY_F7:
writeSpecial(fmap[7]);
break;
case KEY_F8:
writeSpecial(fmap[8]);
break;
case KEY_F9:
writeSpecial(fmap[9]);
break;
case KEY_F10:
writeSpecial(fmap[10]);
break;
case KEY_F11:
writeSpecial(fmap[11]);
break;
case KEY_F12:
writeSpecial(fmap[12]);
break;
case KEY_UP:
writeSpecial(KeyUp[xind]);
break;
case KEY_DOWN:
writeSpecial(KeyDown[xind]);
break;
case KEY_LEFT:
writeSpecial(KeyLeft[xind]);
break;
case KEY_RIGHT:
writeSpecial(KeyRight[xind]);
break;
case KEY_PAGE_DOWN:
writeSpecial(NextScn[xind]);
break;
case KEY_PAGE_UP:
writeSpecial(PrevScn[xind]);
break;
case KEY_INSERT:
writeSpecial(Insert[xind]);
break;
case KEY_DELETE:
writeSpecial(Remove[xind]);
break;
case KEY_BACK_SPACE:
writeSpecial(BackSpace[xind]);
if (localecho) {
if (BackSpace[xind] == "\b") {
putString("\b \b"); // make the last char 'deleted'
} else {
putString(BackSpace[xind]); // echo it
}
}
break;
case KEY_HOME:
writeSpecial(KeyHome[xind]);
break;
case KEY_END:
writeSpecial(KeyEnd[xind]);
break;
case KEY_NUM_LOCK:
if (vms && control) {
writeSpecial(PF1);
}
if (!control)
numlock = !numlock;
break;
case KEY_CAPS_LOCK:
capslock = !capslock;
return;
case KEY_SHIFT:
case KEY_CONTROL:
case KEY_ALT:
return;
default:
break;
}
}
/*
public void keyReleased(KeyEvent evt) {
if (debug > 1) debug("keyReleased("+evt+")");
// ignore
}
*/
/**
* Handle key Typed events for the terminal, this will get
* all normal key types, but no shift/alt/control/numlock.
*/
public void keyTyped(int keyCode, char keyChar, int modifiers) {
boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
if (debug > 1) debug("keyTyped("+keyCode+", "+(int)keyChar+", "+modifiers+")");
if (keyChar == '\t') {
if (shift) {
write(TabKey[1], false);
} else {
if (control) {
write(TabKey[2], false);
} else {
if (alt) {
write(TabKey[3], false);
} else {
write(TabKey[0], false);
}
}
}
return;
}
if (alt) {
write(((char) (keyChar | 0x80)));
return;
}
if (((keyCode == KEY_ENTER) || (keyChar == 10))
&& !control) {
write('\r');
if (localecho) putString("\r\n"); // bad hack
return;
}
if ((keyCode == 10) && !control) {
debug("Sending \\r");
write('\r');
return;
}
// FIXME: on german PC keyboards you have to use Alt-Ctrl-q to get an @,
// so we can't just use it here... will probably break some other VMS
// codes. -Marcus
// if(((!vms && keyChar == '2') || keyChar == '@' || keyChar == ' ')
// && control)
if (((!vms && keyChar == '2') || keyChar == ' ') && control)
write(0);
if (vms) {
if (keyChar == 127 && !control) {
if (shift)
writeSpecial(Insert[0]); // VMS shift delete = insert
else
writeSpecial(Remove[0]); // VMS delete = remove
return;
} else if (control)
switch (keyChar) {
case '0':
writeSpecial(Numpad[0]);
return;
case '1':
writeSpecial(Numpad[1]);
return;
case '2':
writeSpecial(Numpad[2]);
return;
case '3':
writeSpecial(Numpad[3]);
return;
case '4':
writeSpecial(Numpad[4]);
return;
case '5':
writeSpecial(Numpad[5]);
return;
case '6':
writeSpecial(Numpad[6]);
return;
case '7':
writeSpecial(Numpad[7]);
return;
case '8':
writeSpecial(Numpad[8]);
return;
case '9':
writeSpecial(Numpad[9]);
return;
case '.':
writeSpecial(KPPeriod);
return;
case '-':
case 31:
writeSpecial(KPMinus);
return;
case '+':
writeSpecial(KPComma);
return;
case 10:
writeSpecial(KPEnter);
return;
case '/':
writeSpecial(PF2);
return;
case '*':
writeSpecial(PF3);
return;
/* NUMLOCK handled in keyPressed */
default:
break;
}
/* Now what does this do and how did it get here. -Marcus
if (shift && keyChar < 32) {
write(PF1+(char)(keyChar + 64));
return;
}
*/
}
// FIXME: not used?
//String fmap[];
int xind;
xind = 0;
//fmap = FunctionKey;
if (shift) {
//fmap = FunctionKeyShift;
xind = 1;
}
if (control) {
//fmap = FunctionKeyCtrl;
xind = 2;
}
if (alt) {
//fmap = FunctionKeyAlt;
xind = 3;
}
if (keyCode == KEY_ESCAPE) {
writeSpecial(Escape[xind]);
return;
}
if ((modifiers & VDUInput.KEY_ACTION) != 0)
switch (keyCode) {
case KEY_NUMPAD0:
writeSpecial(Numpad[0]);
return;
case KEY_NUMPAD1:
writeSpecial(Numpad[1]);
return;
case KEY_NUMPAD2:
writeSpecial(Numpad[2]);
return;
case KEY_NUMPAD3:
writeSpecial(Numpad[3]);
return;
case KEY_NUMPAD4:
writeSpecial(Numpad[4]);
return;
case KEY_NUMPAD5:
writeSpecial(Numpad[5]);
return;
case KEY_NUMPAD6:
writeSpecial(Numpad[6]);
return;
case KEY_NUMPAD7:
writeSpecial(Numpad[7]);
return;
case KEY_NUMPAD8:
writeSpecial(Numpad[8]);
return;
case KEY_NUMPAD9:
writeSpecial(Numpad[9]);
return;
case KEY_DECIMAL:
writeSpecial(NUMDot[xind]);
return;
case KEY_ADD:
writeSpecial(NUMPlus[xind]);
return;
}
if (!((keyChar == 8) || (keyChar == 127) || (keyChar == '\r') || (keyChar == '\n'))) {
write(keyChar);
return;
}
}
private void handle_dcs(String dcs) {
debugStr.append("DCS: ")
.append(dcs);
debug(debugStr.toString());
debugStr.setLength(0);
}
private void handle_osc(String osc) {
if (osc.length() > 2 && osc.substring(0, 2).equals("4;")) {
// Define color palette
String[] colorData = osc.split(";");
try {
int colorIndex = Integer.parseInt(colorData[1]);
if ("rgb:".equals(colorData[2].substring(0, 4))) {
String[] rgb = colorData[2].substring(4).split("/");
int red = Integer.parseInt(rgb[0].substring(0, 2), 16) & 0xFF;
int green = Integer.parseInt(rgb[1].substring(0, 2), 16) & 0xFF;
int blue = Integer.parseInt(rgb[2].substring(0, 2), 16) & 0xFF;
display.setColor(colorIndex, red, green, blue);
}
} catch (Exception e) {
debugStr.append("OSC: invalid color sequence encountered: ")
.append(osc);
debug(debugStr.toString());
debugStr.setLength(0);
}
} else
debug("OSC: " + osc);
}
private final static char unimap[] = {
//#
//# Name: cp437_DOSLatinUS to Unicode table
//# Unicode version: 1.1
//# Table version: 1.1
//# Table format: Format A
//# Date: 03/31/95
//# Authors: Michel Suignard <michelsu@microsoft.com>
//# Lori Hoerth <lorih@microsoft.com>
//# General notes: none
//#
//# Format: Three tab-separated columns
//# Column #1 is the cp1255_WinHebrew code (in hex)
//# Column #2 is the Unicode (in hex as 0xXXXX)
//# Column #3 is the Unicode name (follows a comment sign, '#')
//#
//# The entries are in cp437_DOSLatinUS order
//#
0x0000, // #NULL
0x0001, // #START OF HEADING
0x0002, // #START OF TEXT
0x0003, // #END OF TEXT
0x0004, // #END OF TRANSMISSION
0x0005, // #ENQUIRY
0x0006, // #ACKNOWLEDGE
0x0007, // #BELL
0x0008, // #BACKSPACE
0x0009, // #HORIZONTAL TABULATION
0x000a, // #LINE FEED
0x000b, // #VERTICAL TABULATION
0x000c, // #FORM FEED
0x000d, // #CARRIAGE RETURN
0x000e, // #SHIFT OUT
0x000f, // #SHIFT IN
0x0010, // #DATA LINK ESCAPE
0x0011, // #DEVICE CONTROL ONE
0x0012, // #DEVICE CONTROL TWO
0x0013, // #DEVICE CONTROL THREE
0x0014, // #DEVICE CONTROL FOUR
0x0015, // #NEGATIVE ACKNOWLEDGE
0x0016, // #SYNCHRONOUS IDLE
0x0017, // #END OF TRANSMISSION BLOCK
0x0018, // #CANCEL
0x0019, // #END OF MEDIUM
0x001a, // #SUBSTITUTE
0x001b, // #ESCAPE
0x001c, // #FILE SEPARATOR
0x001d, // #GROUP SEPARATOR
0x001e, // #RECORD SEPARATOR
0x001f, // #UNIT SEPARATOR
0x0020, // #SPACE
0x0021, // #EXCLAMATION MARK
0x0022, // #QUOTATION MARK
0x0023, // #NUMBER SIGN
0x0024, // #DOLLAR SIGN
0x0025, // #PERCENT SIGN
0x0026, // #AMPERSAND
0x0027, // #APOSTROPHE
0x0028, // #LEFT PARENTHESIS
0x0029, // #RIGHT PARENTHESIS
0x002a, // #ASTERISK
0x002b, // #PLUS SIGN
0x002c, // #COMMA
0x002d, // #HYPHEN-MINUS
0x002e, // #FULL STOP
0x002f, // #SOLIDUS
0x0030, // #DIGIT ZERO
0x0031, // #DIGIT ONE
0x0032, // #DIGIT TWO
0x0033, // #DIGIT THREE
0x0034, // #DIGIT FOUR
0x0035, // #DIGIT FIVE
0x0036, // #DIGIT SIX
0x0037, // #DIGIT SEVEN
0x0038, // #DIGIT EIGHT
0x0039, // #DIGIT NINE
0x003a, // #COLON
0x003b, // #SEMICOLON
0x003c, // #LESS-THAN SIGN
0x003d, // #EQUALS SIGN
0x003e, // #GREATER-THAN SIGN
0x003f, // #QUESTION MARK
0x0040, // #COMMERCIAL AT
0x0041, // #LATIN CAPITAL LETTER A
0x0042, // #LATIN CAPITAL LETTER B
0x0043, // #LATIN CAPITAL LETTER C
0x0044, // #LATIN CAPITAL LETTER D
0x0045, // #LATIN CAPITAL LETTER E
0x0046, // #LATIN CAPITAL LETTER F
0x0047, // #LATIN CAPITAL LETTER G
0x0048, // #LATIN CAPITAL LETTER H
0x0049, // #LATIN CAPITAL LETTER I
0x004a, // #LATIN CAPITAL LETTER J
0x004b, // #LATIN CAPITAL LETTER K
0x004c, // #LATIN CAPITAL LETTER L
0x004d, // #LATIN CAPITAL LETTER M
0x004e, // #LATIN CAPITAL LETTER N
0x004f, // #LATIN CAPITAL LETTER O
0x0050, // #LATIN CAPITAL LETTER P
0x0051, // #LATIN CAPITAL LETTER Q
0x0052, // #LATIN CAPITAL LETTER R
0x0053, // #LATIN CAPITAL LETTER S
0x0054, // #LATIN CAPITAL LETTER T
0x0055, // #LATIN CAPITAL LETTER U
0x0056, // #LATIN CAPITAL LETTER V
0x0057, // #LATIN CAPITAL LETTER W
0x0058, // #LATIN CAPITAL LETTER X
0x0059, // #LATIN CAPITAL LETTER Y
0x005a, // #LATIN CAPITAL LETTER Z
0x005b, // #LEFT SQUARE BRACKET
0x005c, // #REVERSE SOLIDUS
0x005d, // #RIGHT SQUARE BRACKET
0x005e, // #CIRCUMFLEX ACCENT
0x005f, // #LOW LINE
0x0060, // #GRAVE ACCENT
0x0061, // #LATIN SMALL LETTER A
0x0062, // #LATIN SMALL LETTER B
0x0063, // #LATIN SMALL LETTER C
0x0064, // #LATIN SMALL LETTER D
0x0065, // #LATIN SMALL LETTER E
0x0066, // #LATIN SMALL LETTER F
0x0067, // #LATIN SMALL LETTER G
0x0068, // #LATIN SMALL LETTER H
0x0069, // #LATIN SMALL LETTER I
0x006a, // #LATIN SMALL LETTER J
0x006b, // #LATIN SMALL LETTER K
0x006c, // #LATIN SMALL LETTER L
0x006d, // #LATIN SMALL LETTER M
0x006e, // #LATIN SMALL LETTER N
0x006f, // #LATIN SMALL LETTER O
0x0070, // #LATIN SMALL LETTER P
0x0071, // #LATIN SMALL LETTER Q
0x0072, // #LATIN SMALL LETTER R
0x0073, // #LATIN SMALL LETTER S
0x0074, // #LATIN SMALL LETTER T
0x0075, // #LATIN SMALL LETTER U
0x0076, // #LATIN SMALL LETTER V
0x0077, // #LATIN SMALL LETTER W
0x0078, // #LATIN SMALL LETTER X
0x0079, // #LATIN SMALL LETTER Y
0x007a, // #LATIN SMALL LETTER Z
0x007b, // #LEFT CURLY BRACKET
0x007c, // #VERTICAL LINE
0x007d, // #RIGHT CURLY BRACKET
0x007e, // #TILDE
0x007f, // #DELETE
0x00c7, // #LATIN CAPITAL LETTER C WITH CEDILLA
0x00fc, // #LATIN SMALL LETTER U WITH DIAERESIS
0x00e9, // #LATIN SMALL LETTER E WITH ACUTE
0x00e2, // #LATIN SMALL LETTER A WITH CIRCUMFLEX
0x00e4, // #LATIN SMALL LETTER A WITH DIAERESIS
0x00e0, // #LATIN SMALL LETTER A WITH GRAVE
0x00e5, // #LATIN SMALL LETTER A WITH RING ABOVE
0x00e7, // #LATIN SMALL LETTER C WITH CEDILLA
0x00ea, // #LATIN SMALL LETTER E WITH CIRCUMFLEX
0x00eb, // #LATIN SMALL LETTER E WITH DIAERESIS
0x00e8, // #LATIN SMALL LETTER E WITH GRAVE
0x00ef, // #LATIN SMALL LETTER I WITH DIAERESIS
0x00ee, // #LATIN SMALL LETTER I WITH CIRCUMFLEX
0x00ec, // #LATIN SMALL LETTER I WITH GRAVE
0x00c4, // #LATIN CAPITAL LETTER A WITH DIAERESIS
0x00c5, // #LATIN CAPITAL LETTER A WITH RING ABOVE
0x00c9, // #LATIN CAPITAL LETTER E WITH ACUTE
0x00e6, // #LATIN SMALL LIGATURE AE
0x00c6, // #LATIN CAPITAL LIGATURE AE
0x00f4, // #LATIN SMALL LETTER O WITH CIRCUMFLEX
0x00f6, // #LATIN SMALL LETTER O WITH DIAERESIS
0x00f2, // #LATIN SMALL LETTER O WITH GRAVE
0x00fb, // #LATIN SMALL LETTER U WITH CIRCUMFLEX
0x00f9, // #LATIN SMALL LETTER U WITH GRAVE
0x00ff, // #LATIN SMALL LETTER Y WITH DIAERESIS
0x00d6, // #LATIN CAPITAL LETTER O WITH DIAERESIS
0x00dc, // #LATIN CAPITAL LETTER U WITH DIAERESIS
0x00a2, // #CENT SIGN
0x00a3, // #POUND SIGN
0x00a5, // #YEN SIGN
0x20a7, // #PESETA SIGN
0x0192, // #LATIN SMALL LETTER F WITH HOOK
0x00e1, // #LATIN SMALL LETTER A WITH ACUTE
0x00ed, // #LATIN SMALL LETTER I WITH ACUTE
0x00f3, // #LATIN SMALL LETTER O WITH ACUTE
0x00fa, // #LATIN SMALL LETTER U WITH ACUTE
0x00f1, // #LATIN SMALL LETTER N WITH TILDE
0x00d1, // #LATIN CAPITAL LETTER N WITH TILDE
0x00aa, // #FEMININE ORDINAL INDICATOR
0x00ba, // #MASCULINE ORDINAL INDICATOR
0x00bf, // #INVERTED QUESTION MARK
0x2310, // #REVERSED NOT SIGN
0x00ac, // #NOT SIGN
0x00bd, // #VULGAR FRACTION ONE HALF
0x00bc, // #VULGAR FRACTION ONE QUARTER
0x00a1, // #INVERTED EXCLAMATION MARK
0x00ab, // #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
0x00bb, // #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
0x2591, // #LIGHT SHADE
0x2592, // #MEDIUM SHADE
0x2593, // #DARK SHADE
0x2502, // #BOX DRAWINGS LIGHT VERTICAL
0x2524, // #BOX DRAWINGS LIGHT VERTICAL AND LEFT
0x2561, // #BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE
0x2562, // #BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE
0x2556, // #BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE
0x2555, // #BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE
0x2563, // #BOX DRAWINGS DOUBLE VERTICAL AND LEFT
0x2551, // #BOX DRAWINGS DOUBLE VERTICAL
0x2557, // #BOX DRAWINGS DOUBLE DOWN AND LEFT
0x255d, // #BOX DRAWINGS DOUBLE UP AND LEFT
0x255c, // #BOX DRAWINGS UP DOUBLE AND LEFT SINGLE
0x255b, // #BOX DRAWINGS UP SINGLE AND LEFT DOUBLE
0x2510, // #BOX DRAWINGS LIGHT DOWN AND LEFT
0x2514, // #BOX DRAWINGS LIGHT UP AND RIGHT
0x2534, // #BOX DRAWINGS LIGHT UP AND HORIZONTAL
0x252c, // #BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
0x251c, // #BOX DRAWINGS LIGHT VERTICAL AND RIGHT
0x2500, // #BOX DRAWINGS LIGHT HORIZONTAL
0x253c, // #BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL
0x255e, // #BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE
0x255f, // #BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE
0x255a, // #BOX DRAWINGS DOUBLE UP AND RIGHT
0x2554, // #BOX DRAWINGS DOUBLE DOWN AND RIGHT
0x2569, // #BOX DRAWINGS DOUBLE UP AND HORIZONTAL
0x2566, // #BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL
0x2560, // #BOX DRAWINGS DOUBLE VERTICAL AND RIGHT
0x2550, // #BOX DRAWINGS DOUBLE HORIZONTAL
0x256c, // #BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL
0x2567, // #BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE
0x2568, // #BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE
0x2564, // #BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE
0x2565, // #BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE
0x2559, // #BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE
0x2558, // #BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE
0x2552, // #BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE
0x2553, // #BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE
0x256b, // #BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE
0x256a, // #BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE
0x2518, // #BOX DRAWINGS LIGHT UP AND LEFT
0x250c, // #BOX DRAWINGS LIGHT DOWN AND RIGHT
0x2588, // #FULL BLOCK
0x2584, // #LOWER HALF BLOCK
0x258c, // #LEFT HALF BLOCK
0x2590, // #RIGHT HALF BLOCK
0x2580, // #UPPER HALF BLOCK
0x03b1, // #GREEK SMALL LETTER ALPHA
0x00df, // #LATIN SMALL LETTER SHARP S
0x0393, // #GREEK CAPITAL LETTER GAMMA
0x03c0, // #GREEK SMALL LETTER PI
0x03a3, // #GREEK CAPITAL LETTER SIGMA
0x03c3, // #GREEK SMALL LETTER SIGMA
0x00b5, // #MICRO SIGN
0x03c4, // #GREEK SMALL LETTER TAU
0x03a6, // #GREEK CAPITAL LETTER PHI
0x0398, // #GREEK CAPITAL LETTER THETA
0x03a9, // #GREEK CAPITAL LETTER OMEGA
0x03b4, // #GREEK SMALL LETTER DELTA
0x221e, // #INFINITY
0x03c6, // #GREEK SMALL LETTER PHI
0x03b5, // #GREEK SMALL LETTER EPSILON
0x2229, // #INTERSECTION
0x2261, // #IDENTICAL TO
0x00b1, // #PLUS-MINUS SIGN
0x2265, // #GREATER-THAN OR EQUAL TO
0x2264, // #LESS-THAN OR EQUAL TO
0x2320, // #TOP HALF INTEGRAL
0x2321, // #BOTTOM HALF INTEGRAL
0x00f7, // #DIVISION SIGN
0x2248, // #ALMOST EQUAL TO
0x00b0, // #DEGREE SIGN
0x2219, // #BULLET OPERATOR
0x00b7, // #MIDDLE DOT
0x221a, // #SQUARE ROOT
0x207f, // #SUPERSCRIPT LATIN SMALL LETTER N
0x00b2, // #SUPERSCRIPT TWO
0x25a0, // #BLACK SQUARE
0x00a0, // #NO-BREAK SPACE
};
public char map_cp850_unicode(char x) {
if (x >= 0x100)
return x;
return unimap[x];
}
private void _SetCursor(int row, int col) {
int maxr = height - 1;
int tm = getTopMargin();
R = (row < 0)?0: row;
C = (col < 0)?0: (col >= width) ? width - 1 : col;
if (!moveoutsidemargins) {
R += tm;
maxr = getBottomMargin();
}
if (R > maxr) R = maxr;
}
private void putChar(char c, boolean isWide, boolean doshowcursor) {
int rows = this.height; //statusline
int columns = this.width;
// byte msg[];
// if (debug > 4) {
// debugStr.append("putChar(")
// .append(c)
// .append(" [")
// .append((int) c)
// .append("]) at R=")
// .append(R)
// .append(" , C=")
// .append(C)
// .append(", columns=")
// .append(columns)
// .append(", rows=")
// .append(rows);
// debug(debugStr.toString());
// debugStr.setLength(0);
// }
// markLine(R, 1);
// if (c > 255) {
// if (debug > 0)
// debug("char > 255:" + (int) c);
// //return;
// }
switch (term_state) {
case TSTATE_DATA:
/* FIXME: we shouldn't use chars with bit 8 set if ibmcharset.
* probably... but some BBS do anyway...
*/
if (!useibmcharset) {
boolean doneflag = true;
switch (c) {
case OSC:
osc = "";
term_state = TSTATE_OSC;
break;
case RI:
if (R > getTopMargin())
R--;
else
insertLine(R, 1, SCROLL_DOWN);
if (debug > 1)
debug("RI");
break;
case IND:
if (debug > 2) {
debugStr.append("IND at ")
.append(R)
.append(", tm is ")
.append(getTopMargin())
.append(", bm is ")
.append(getBottomMargin());
debug(debugStr.toString());
debugStr.setLength(0);
}
if (R == getBottomMargin() || R == rows - 1)
insertLine(R, 1, SCROLL_UP);
else
R++;
if (debug > 1)
debug("IND (at " + R + " )");
break;
case NEL:
if (R == getBottomMargin() || R == rows - 1)
insertLine(R, 1, SCROLL_UP);
else
R++;
C = 0;
if (debug > 1)
debug("NEL (at " + R + " )");
break;
case HTS:
Tabs[C] = 1;
if (debug > 1)
debug("HTS");
break;
case DCS:
dcs = "";
term_state = TSTATE_DCS;
break;
default:
doneflag = false;
break;
}
if (doneflag) break;
}
switch (c) {
case SS3:
onegl = 3;
break;
case SS2:
onegl = 2;
break;
case CSI: // should be in the 8bit section, but some BBS use this
DCEvar = 0;
DCEvars[0] = 0;
DCEvars[1] = 0;
DCEvars[2] = 0;
DCEvars[3] = 0;
term_state = TSTATE_CSI;
break;
case ESC:
term_state = TSTATE_ESC;
lastwaslf = 0;
break;
case 5: /* ENQ */
write(answerBack, false);
break;
case 12:
/* FormFeed, Home for the BBS world */
deleteArea(0, 0, columns, rows, attributes);
C = R = 0;
break;
case '\b': /* 8 */
C--;
if (C < 0)
C = 0;
lastwaslf = 0;
break;
case '\t':
do {
// Don't overwrite or insert! TABS are not destructive, but movement!
C++;
} while (C < columns && (Tabs[C] == 0));
lastwaslf = 0;
break;
case '\r': // 13 CR
C = 0;
break;
case '\n': // 10 LF
if (debug > 3)
debug("R= " + R + ", bm " + getBottomMargin() + ", tm=" + getTopMargin() + ", rows=" + rows);
if (!vms) {
if (lastwaslf != 0 && lastwaslf != c) // Ray: I do not understand this logic.
break;
lastwaslf = c;
/*C = 0;*/
}
if (R == getBottomMargin() || R >= rows - 1)
insertLine(R, 1, SCROLL_UP);
else
R++;
break;
case 7:
beep();
break;
case '\016': /* SMACS , as */
/* ^N, Shift out - Put G1 into GL */
gl = 1;
usedcharsets = true;
break;
case '\017': /* RMACS , ae */
/* ^O, Shift in - Put G0 into GL */
gl = 0;
usedcharsets = true;
break;
default:
{
int thisgl = gl;
if (onegl >= 0) {
thisgl = onegl;
onegl = -1;
}
lastwaslf = 0;
if (c < 32) {
if (c != 0)
if (debug > 0)
debug("TSTATE_DATA char: " + ((int) c));
/*break; some BBS really want those characters, like hearst etc. */
if (c == 0) /* print 0 ... you bet */
break;
}
if (C >= columns) {
if (wraparound) {
int bot = rows;
// If we're in the scroll region, check against the bottom margin
if (R <= getBottomMargin() && R >= getTopMargin())
bot = getBottomMargin() + 1;
if (R < bot - 1)
R++;
else {
if (debug > 3) debug("scrolling due to wrap at " + R);
insertLine(R, 1, SCROLL_UP);
}
C = 0;
} else {
// cursor stays on last character.
C = columns - 1;
}
}
boolean mapped = false;
// Mapping if DEC Special is chosen charset
if (usedcharsets) {
if (c >= '\u0020' && c <= '\u007f') {
switch (gx[thisgl]) {
case '0':
// Remap SCOANSI line drawing to VT100 line drawing chars
// for our SCO using customers.
if (terminalID.equals("scoansi") || terminalID.equals("ansi")) {
for (int i = 0; i < scoansi_acs.length(); i += 2) {
if (c == scoansi_acs.charAt(i)) {
c = scoansi_acs.charAt(i + 1);
break;
}
}
}
if (c >= '\u005f' && c <= '\u007e') {
c = DECSPECIAL[(short) c - 0x5f];
mapped = true;
}
break;
case '<': // 'user preferred' is currently 'ISO Latin-1 suppl
c = (char) ((c & 0x7f) | 0x80);
mapped = true;
break;
case 'A':
case 'B': // Latin-1 , ASCII -> fall through
mapped = true;
break;
default:
debug("Unsupported GL mapping: " + gx[thisgl]);
break;
}
}
if (!mapped && (c >= '\u0080' && c <= '\u00ff')) {
switch (gx[gr]) {
case '0':
if (c >= '\u00df' && c <= '\u00fe') {
c = DECSPECIAL[c - '\u00df'];
mapped = true;
}
break;
case '<':
case 'A':
case 'B':
mapped = true;
break;
default:
debug("Unsupported GR mapping: " + gx[gr]);
break;
}
}
}
if (!mapped && useibmcharset)
c = map_cp850_unicode(c);
/*if(true || (statusmode == 0)) { */
if (isWide) {
if (C >= columns - 1) {
if (wraparound) {
int bot = rows;
// If we're in the scroll region, check against the bottom margin
if (R <= getBottomMargin() && R >= getTopMargin())
bot = getBottomMargin() + 1;
if (R < bot - 1)
R++;
else {
if (debug > 3) debug("scrolling due to wrap at " + R);
insertLine(R, 1, SCROLL_UP);
}
C = 0;
} else {
// cursor stays on last wide character.
C = columns - 2;
}
}
}
if (insertmode == 1) {
if (isWide) {
insertChar(C++, R, c, attributes | FULLWIDTH);
insertChar(C, R, ' ', attributes | FULLWIDTH);
} else
insertChar(C, R, c, attributes);
} else {
if (isWide) {
putChar(C++, R, c, attributes | FULLWIDTH);
putChar(C, R, ' ', attributes | FULLWIDTH);
} else
putChar(C, R, c, attributes);
}
/*
} else {
if (insertmode==1) {
insertChar(C, rows, c, attributes);
} else {
putChar(C, rows, c, attributes);
}
}
*/
C++;
break;
}
} /* switch(c) */
break;
case TSTATE_OSC:
if ((c < 0x20) && (c != ESC)) {// NP - No printing character
handle_osc(osc);
term_state = TSTATE_DATA;
break;
}
//but check for vt102 ESC \
if (c == '\\' && osc.charAt(osc.length() - 1) == ESC) {
handle_osc(osc);
term_state = TSTATE_DATA;
break;
}
osc = osc + c;
break;
case TSTATE_ESCSPACE:
term_state = TSTATE_DATA;
switch (c) {
case 'F': /* S7C1T, Disable output of 8-bit controls, use 7-bit */
output8bit = false;
break;
case 'G': /* S8C1T, Enable output of 8-bit control codes*/
output8bit = true;
break;
default:
debug("ESC <space> " + c + " unhandled.");
}
break;
case TSTATE_ESC:
term_state = TSTATE_DATA;
switch (c) {
case ' ':
term_state = TSTATE_ESCSPACE;
break;
case '#':
term_state = TSTATE_ESCSQUARE;
break;
case 'c':
/* Hard terminal reset */
reset();
break;
case '[':
DCEvar = 0;
DCEvars[0] = 0;
DCEvars[1] = 0;
DCEvars[2] = 0;
DCEvars[3] = 0;
term_state = TSTATE_CSI;
break;
case ']':
osc = "";
term_state = TSTATE_OSC;
break;
case 'P':
dcs = "";
term_state = TSTATE_DCS;
break;
case 'A': /* CUU */
R--;
if (R < 0) R = 0;
break;
case 'B': /* CUD */
R++;
if (R >= rows) R = rows - 1;
break;
case 'C':
C++;
if (C >= columns) C = columns - 1;
break;
case 'I': // RI
insertLine(R, 1, SCROLL_DOWN);
break;
case 'E': /* NEL */
if (R == getBottomMargin() || R == rows - 1)
insertLine(R, 1, SCROLL_UP);
else
R++;
C = 0;
if (debug > 1)
debug("ESC E (at " + R + ")");
break;
case 'D': /* IND */
if (R == getBottomMargin() || R == rows - 1)
insertLine(R, 1, SCROLL_UP);
else
R++;
if (debug > 1)
debug("ESC D (at " + R + " )");
break;
case 'J': /* erase to end of screen */
if (R < rows - 1)
deleteArea(0, R + 1, columns, rows - R - 1, attributes);
if (C < columns - 1)
deleteArea(C, R, columns - C, 1, attributes);
break;
case 'K':
if (C < columns - 1)
deleteArea(C, R, columns - C, 1, attributes);
break;
case 'M': // RI
debug("ESC M : R is "+R+", tm is "+getTopMargin()+", bm is "+getBottomMargin());
if (R > getTopMargin()) { // just go up 1 line.
R--;
} else { // scroll down
insertLine(R, 1, SCROLL_DOWN);
}
/* else do nothing ; */
if (debug > 2)
debug("ESC M ");
break;
case 'H':
if (debug > 1)
debug("ESC H at " + C);
/* right border probably ...*/
if (C >= columns)
C = columns - 1;
Tabs[C] = 1;
break;
case 'N': // SS2
onegl = 2;
break;
case 'O': // SS3
onegl = 3;
break;
case '=':
/*application keypad*/
if (debug > 0)
debug("ESC =");
keypadmode = true;
break;
case '<': /* vt52 mode off */
vt52mode = false;
break;
case '>': /*normal keypad*/
if (debug > 0)
debug("ESC >");
keypadmode = false;
break;
case '7': /* DECSC: save cursor, attributes */
Sc = C;
Sr = R;
Sgl = gl;
Sgr = gr;
Sa = attributes;
Sgx = new char[4];
for (int i = 0; i < 4; i++) Sgx[i] = gx[i];
if (debug > 1)
debug("ESC 7");
break;
case '8': /* DECRC: restore cursor, attributes */
C = Sc;
R = Sr;
gl = Sgl;
gr = Sgr;
if (Sgx != null)
for (int i = 0; i < 4; i++) gx[i] = Sgx[i];
attributes = Sa;
if (debug > 1)
debug("ESC 8");
break;
case '(': /* Designate G0 Character set (ISO 2022) */
term_state = TSTATE_SETG0;
usedcharsets = true;
break;
case ')': /* Designate G1 character set (ISO 2022) */
term_state = TSTATE_SETG1;
usedcharsets = true;
break;
case '*': /* Designate G2 Character set (ISO 2022) */
term_state = TSTATE_SETG2;
usedcharsets = true;
break;
case '+': /* Designate G3 Character set (ISO 2022) */
term_state = TSTATE_SETG3;
usedcharsets = true;
break;
case '~': /* Locking Shift 1, right */
gr = 1;
usedcharsets = true;
break;
case 'n': /* Locking Shift 2 */
gl = 2;
usedcharsets = true;
break;
case '}': /* Locking Shift 2, right */
gr = 2;
usedcharsets = true;
break;
case 'o': /* Locking Shift 3 */
gl = 3;
usedcharsets = true;
break;
case '|': /* Locking Shift 3, right */
gr = 3;
usedcharsets = true;
break;
case 'Y': /* vt52 cursor address mode , next chars are x,y */
term_state = TSTATE_VT52Y;
break;
case '_':
term_state = TSTATE_TITLE;
break;
case '\\':
// TODO save title
term_state = TSTATE_DATA;
break;
default:
debug("ESC unknown letter: " + c + " (" + ((int) c) + ")");
break;
}
break;
case TSTATE_VT52X:
C = c - 37;
if (C < 0)
C = 0;
else if (C >= width)
C = width - 1;
term_state = TSTATE_VT52Y;
break;
case TSTATE_VT52Y:
R = c - 37;
if (R < 0)
R = 0;
else if (R >= height)
R = height - 1;
term_state = TSTATE_DATA;
break;
case TSTATE_SETG0:
if (c != '0' && c != 'A' && c != 'B' && c != '<')
debug("ESC ( " + c + ": G0 char set? (" + ((int) c) + ")");
else {
if (debug > 2) debug("ESC ( : G0 char set (" + c + " " + ((int) c) + ")");
gx[0] = c;
}
term_state = TSTATE_DATA;
break;
case TSTATE_SETG1:
if (c != '0' && c != 'A' && c != 'B' && c != '<') {
debug("ESC ) " + c + " (" + ((int) c) + ") :G1 char set?");
} else {
if (debug > 2) debug("ESC ) :G1 char set (" + c + " " + ((int) c) + ")");
gx[1] = c;
}
term_state = TSTATE_DATA;
break;
case TSTATE_SETG2:
if (c != '0' && c != 'A' && c != 'B' && c != '<')
debug("ESC*:G2 char set? (" + ((int) c) + ")");
else {
if (debug > 2) debug("ESC*:G2 char set (" + c + " " + ((int) c) + ")");
gx[2] = c;
}
term_state = TSTATE_DATA;
break;
case TSTATE_SETG3:
if (c != '0' && c != 'A' && c != 'B' && c != '<')
debug("ESC+:G3 char set? (" + ((int) c) + ")");
else {
if (debug > 2) debug("ESC+:G3 char set (" + c + " " + ((int) c) + ")");
gx[3] = c;
}
term_state = TSTATE_DATA;
break;
case TSTATE_ESCSQUARE:
switch (c) {
case '8':
for (int i = 0; i < columns; i++)
for (int j = 0; j < rows; j++)
putChar(i, j, 'E', 0);
break;
default:
debug("ESC # " + c + " not supported.");
break;
}
term_state = TSTATE_DATA;
break;
case TSTATE_DCS:
if (c == '\\' && dcs.charAt(dcs.length() - 1) == ESC) {
handle_dcs(dcs);
term_state = TSTATE_DATA;
break;
}
dcs = dcs + c;
break;
case TSTATE_DCEQ:
term_state = TSTATE_DATA;
switch (c) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
term_state = TSTATE_DCEQ;
break;
case ';':
DCEvar++;
DCEvars[DCEvar] = 0;
term_state = TSTATE_DCEQ;
break;
case 's': // XTERM_SAVE missing!
if (true || debug > 1)
debug("ESC [ ? " + DCEvars[0] + " s unimplemented!");
break;
case 'r': // XTERM_RESTORE
if (true || debug > 1)
debug("ESC [ ? " + DCEvars[0] + " r");
/* DEC Mode reset */
for (int i = 0; i <= DCEvar; i++) {
switch (DCEvars[i]) {
case 3: /* 80 columns*/
setScreenSize(80, height, true);
break;
case 4: /* scrolling mode, smooth */
break;
case 5: /* light background */
break;
case 6: /* DECOM (Origin Mode) move inside margins. */
moveoutsidemargins = true;
break;
case 7: /* DECAWM: Autowrap Mode */
wraparound = false;
break;
case 12:/* local echo off */
break;
case 9: /* X10 mouse */
case 1000: /* xterm style mouse report on */
case 1001:
case 1002:
case 1003:
mouserpt = DCEvars[i];
break;
default:
debug("ESC [ ? " + DCEvars[0] + " r, unimplemented!");
}
}
break;
case 'h': // DECSET
if (debug > 0)
debug("ESC [ ? " + DCEvars[0] + " h");
/* DEC Mode set */
for (int i = 0; i <= DCEvar; i++) {
switch (DCEvars[i]) {
case 1: /* Application cursor keys */
KeyUp[0] = "\u001bOA";
KeyDown[0] = "\u001bOB";
KeyRight[0] = "\u001bOC";
KeyLeft[0] = "\u001bOD";
break;
case 2: /* DECANM */
vt52mode = false;
break;
case 3: /* 132 columns*/
setScreenSize(132, height, true);
break;
case 6: /* DECOM: move inside margins. */
moveoutsidemargins = false;
break;
case 7: /* DECAWM: Autowrap Mode */
wraparound = true;
break;
case 25: /* turn cursor on */
showCursor(true);
break;
case 9: /* X10 mouse */
case 1000: /* xterm style mouse report on */
case 1001:
case 1002:
case 1003:
mouserpt = DCEvars[i];
break;
/* unimplemented stuff, fall through */
/* 4 - scrolling mode, smooth */
/* 5 - light background */
/* 12 - local echo off */
/* 18 - DECPFF - Printer Form Feed Mode -> On */
/* 19 - DECPEX - Printer Extent Mode -> Screen */
default:
debug("ESC [ ? " + DCEvars[0] + " h, unsupported.");
break;
}
}
break;
case 'i': // DEC Printer Control, autoprint, echo screenchars to printer
// This is different to CSI i!
// Also: "Autoprint prints a final display line only when the
// cursor is moved off the line by an autowrap or LF, FF, or
// VT (otherwise do not print the line)."
switch (DCEvars[0]) {
case 1:
if (debug > 1)
debug("CSI ? 1 i : Print line containing cursor");
break;
case 4:
if (debug > 1)
debug("CSI ? 4 i : Start passthrough printing");
break;
case 5:
if (debug > 1)
debug("CSI ? 4 i : Stop passthrough printing");
break;
}
break;
case 'l': //DECRST
/* DEC Mode reset */
if (debug > 0)
debug("ESC [ ? " + DCEvars[0] + " l");
for (int i = 0; i <= DCEvar; i++) {
switch (DCEvars[i]) {
case 1: /* Application cursor keys */
KeyUp[0] = "\u001b[A";
KeyDown[0] = "\u001b[B";
KeyRight[0] = "\u001b[C";
KeyLeft[0] = "\u001b[D";
break;
case 2: /* DECANM */
vt52mode = true;
break;
case 3: /* 80 columns*/
setScreenSize(80, height, true);
break;
case 6: /* DECOM: move outside margins. */
moveoutsidemargins = true;
break;
case 7: /* DECAWM: Autowrap Mode OFF */
wraparound = false;
break;
case 25: /* turn cursor off */
showCursor(false);
break;
/* Unimplemented stuff: */
/* 4 - scrolling mode, jump */
/* 5 - dark background */
/* 7 - DECAWM - no wrap around mode */
/* 12 - local echo on */
/* 18 - DECPFF - Printer Form Feed Mode -> Off*/
/* 19 - DECPEX - Printer Extent Mode -> Scrolling Region */
case 9: /* X10 mouse */
case 1000: /* xterm style mouse report OFF */
case 1001:
case 1002:
case 1003:
mouserpt = 0;
break;
default:
debug("ESC [ ? " + DCEvars[0] + " l, unsupported.");
break;
}
}
break;
case 'n':
if (debug > 0)
debug("ESC [ ? " + DCEvars[0] + " n");
switch (DCEvars[0]) {
case 15:
/* printer? no printer. */
write((ESC) + "[?13n", false);
debug("ESC[5n");
break;
default:
debug("ESC [ ? " + DCEvars[0] + " n, unsupported.");
break;
}
break;
default:
debug("ESC [ ? " + DCEvars[0] + " " + c + ", unsupported.");
break;
}
break;
case TSTATE_CSI_EX:
term_state = TSTATE_DATA;
switch (c) {
case ESC:
term_state = TSTATE_ESC;
break;
default:
debug("Unknown character ESC[! character is " + (int) c);
break;
}
break;
case TSTATE_CSI_TICKS:
term_state = TSTATE_DATA;
switch (c) {
case 'p':
debug("Conformance level: " + DCEvars[0] + " (unsupported)," + DCEvars[1]);
if (DCEvars[0] == 61) {
output8bit = false;
break;
}
if (DCEvars[1] == 1) {
output8bit = false;
} else {
output8bit = true; /* 0 or 2 */
}
break;
default:
debug("Unknown ESC [... \"" + c);
break;
}
break;
case TSTATE_CSI_EQUAL:
term_state = TSTATE_DATA;
switch (c) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
term_state = TSTATE_CSI_EQUAL;
break;
case ';':
DCEvar++;
DCEvars[DCEvar] = 0;
term_state = TSTATE_CSI_EQUAL;
break;
case 'F': /* SCO ANSI foreground */
{
int newcolor;
debug("ESC [ = "+DCEvars[0]+" F");
attributes &= ~COLOR_FG;
newcolor = ((DCEvars[0] & 1) << 2) |
(DCEvars[0] & 2) |
((DCEvars[0] & 4) >> 2) ;
attributes |= (newcolor+1) << COLOR_FG_SHIFT;
break;
}
case 'G': /* SCO ANSI background */
{
int newcolor;
debug("ESC [ = "+DCEvars[0]+" G");
attributes &= ~COLOR_BG;
newcolor = ((DCEvars[0] & 1) << 2) |
(DCEvars[0] & 2) |
((DCEvars[0] & 4) >> 2) ;
attributes |= (newcolor+1) << COLOR_BG_SHIFT;
break;
}
default:
debugStr.append("Unknown ESC [ = ");
for (int i=0;i<=DCEvar;i++) {
debugStr.append(DCEvars[i])
.append(',');
}
debugStr.append(c);
debug(debugStr.toString());
debugStr.setLength(0);
break;
}
break;
case TSTATE_CSI_DOLLAR:
term_state = TSTATE_DATA;
switch (c) {
case '}':
debug("Active Status Display now " + DCEvars[0]);
statusmode = DCEvars[0];
break;
/* bad documentation?
case '-':
debug("Set Status Display now "+DCEvars[0]);
break;
*/
case '~':
debug("Status Line mode now " + DCEvars[0]);
break;
default:
debug("UNKNOWN Status Display code " + c + ", with Pn=" + DCEvars[0]);
break;
}
break;
case TSTATE_CSI:
term_state = TSTATE_DATA;
switch (c) {
case '"':
term_state = TSTATE_CSI_TICKS;
break;
case '$':
term_state = TSTATE_CSI_DOLLAR;
break;
case '=':
term_state = TSTATE_CSI_EQUAL;
break;
case '!':
term_state = TSTATE_CSI_EX;
break;
case '?':
DCEvar = 0;
DCEvars[0] = 0;
term_state = TSTATE_DCEQ;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
term_state = TSTATE_CSI;
break;
case ';':
DCEvar++;
DCEvars[DCEvar] = 0;
term_state = TSTATE_CSI;
break;
case 'c':/* send primary device attributes */
/* send (ESC[?61c) */
String subcode = "";
if (terminalID.equals("vt320")) subcode = "63;";
if (terminalID.equals("vt220")) subcode = "62;";
if (terminalID.equals("vt100")) subcode = "61;";
write((ESC) + "[?" + subcode + "1;2c", false);
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " c");
break;
case 'q':
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " q");
break;
case 'g':
/* used for tabsets */
switch (DCEvars[0]) {
case 3:/* clear them */
Tabs = new byte[width];
break;
case 0:
Tabs[C] = 0;
break;
}
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " g");
break;
case 'h':
switch (DCEvars[0]) {
case 4:
insertmode = 1;
break;
case 20:
debug("Setting CRLF to TRUE");
sendcrlf = true;
break;
default:
debug("unsupported: ESC [ " + DCEvars[0] + " h");
break;
}
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " h");
break;
case 'i': // Printer Controller mode.
// "Transparent printing sends all output, except the CSI 4 i
// termination string, to the printer and not the screen,
// uses an 8-bit channel if no parity so NUL and DEL will be
// seen by the printer and by the termination recognizer code,
// and all translation and character set selections are
// bypassed."
switch (DCEvars[0]) {
case 0:
if (debug > 1)
debug("CSI 0 i: Print Screen, not implemented.");
break;
case 4:
if (debug > 1)
debug("CSI 4 i: Enable Transparent Printing, not implemented.");
break;
case 5:
if (debug > 1)
debug("CSI 4/5 i: Disable Transparent Printing, not implemented.");
break;
default:
debug("ESC [ " + DCEvars[0] + " i, unimplemented!");
}
break;
case 'l':
switch (DCEvars[0]) {
case 4:
insertmode = 0;
break;
case 20:
debug("Setting CRLF to FALSE");
sendcrlf = false;
break;
default:
debug("ESC [ " + DCEvars[0] + " l, unimplemented!");
break;
}
break;
case 'A': // CUU
{
int limit;
/* FIXME: xterm only cares about 0 and topmargin */
if (R >= getTopMargin()) {
limit = getTopMargin();
} else
limit = 0;
if (DCEvars[0] == 0)
R--;
else
R -= DCEvars[0];
if (R < limit)
R = limit;
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " A");
break;
}
case 'B': // CUD
/* cursor down n (1) times */
{
int limit;
if (R <= getBottomMargin()) {
limit = getBottomMargin();
} else
limit = rows - 1;
if (DCEvars[0] == 0)
R++;
else
R += DCEvars[0];
if (R > limit)
R = limit;
else {
if (debug > 2) debug("Not limited.");
}
if (debug > 2) debug("to: " + R);
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " B (at C=" + C + ")");
break;
}
case 'C':
if (DCEvars[0] == 0)
DCEvars[0] = 1;
while (DCEvars[0]-- > 0) {
C++;
}
if (C >= columns)
C = columns - 1;
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " C");
break;
case 'd': // CVA
R = DCEvars[0];
if (R < 0)
R = 0;
else if (R >= height)
R = height - 1;
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " d");
break;
case 'D':
if (DCEvars[0] == 0)
DCEvars[0] = 1;
while (DCEvars[0]-- > 0) {
C--;
}
if (C < 0) C = 0;
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " D");
break;
case 'r': // DECSTBM
if (DCEvar > 0) // Ray: Any argument is optional
{
R = DCEvars[1] - 1;
if (R < 0)
R = rows - 1;
else if (R >= rows) {
R = rows - 1;
}
} else
R = rows - 1;
int bot = R;
if (R >= DCEvars[0]) {
R = DCEvars[0] - 1;
if (R < 0)
R = 0;
}
setMargins(R, bot);
_SetCursor(0, 0);
if (debug > 1)
debug("ESC [" + DCEvars[0] + " ; " + DCEvars[1] + " r");
break;
case 'G': /* CUP / cursor absolute column */
C = DCEvars[0];
if (C < 0)
C = 0;
else if (C >= width)
C = width - 1;
if (debug > 1) debug("ESC [ " + DCEvars[0] + " G");
break;
case 'H': /* CUP / cursor position */
/* gets 2 arguments */
_SetCursor(DCEvars[0] - 1, DCEvars[1] - 1);
if (debug > 2) {
debug("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " H, moveoutsidemargins " + moveoutsidemargins);
debug(" -> R now " + R + ", C now " + C);
}
break;
case 'f': /* move cursor 2 */
/* gets 2 arguments */
R = DCEvars[0] - 1;
C = DCEvars[1] - 1;
if (C < 0)
C = 0;
else if (C >= width)
C = width - 1;
if (R < 0)
R = 0;
else if (R >= height)
R = height - 1;
if (debug > 2)
debug("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " f");
break;
case 'S': /* ind aka 'scroll forward' */
if (DCEvars[0] == 0)
insertLine(rows - 1, SCROLL_UP);
else
insertLine(rows - 1, DCEvars[0], SCROLL_UP);
break;
case 'L':
/* insert n lines */
if (DCEvars[0] == 0)
insertLine(R, SCROLL_DOWN);
else
insertLine(R, DCEvars[0], SCROLL_DOWN);
if (debug > 1)
debug("ESC [ " + DCEvars[0] + "" + (c) + " (at R " + R + ")");
break;
case 'T': /* 'ri' aka scroll backward */
if (DCEvars[0] == 0)
insertLine(0, SCROLL_DOWN);
else
insertLine(0, DCEvars[0], SCROLL_DOWN);
break;
case 'M':
if (debug > 1)
debug("ESC [ " + DCEvars[0] + "" + (c) + " at R=" + R);
if (DCEvars[0] == 0)
deleteLine(R);
else
for (int i = 0; i < DCEvars[0]; i++)
deleteLine(R);
break;
case 'K':
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " K");
/* clear in line */
switch (DCEvars[0]) {
case 6: /* 97801 uses ESC[6K for delete to end of line */
case 0:/*clear to right*/
if (C < columns - 1)
deleteArea(C, R, columns - C, 1, attributes);
break;
case 1:/*clear to the left, including this */
if (C > 0)
deleteArea(0, R, C + 1, 1, attributes);
break;
case 2:/*clear whole line */
deleteArea(0, R, columns, 1, attributes);
break;
}
break;
case 'J':
/* clear below current line */
switch (DCEvars[0]) {
case 0:
if (R < rows - 1)
deleteArea(0, R + 1, columns, rows - R - 1, attributes);
if (C < columns - 1)
deleteArea(C, R, columns - C, 1, attributes);
break;
case 1:
if (R > 0)
deleteArea(0, 0, columns, R, attributes);
if (C > 0)
deleteArea(0, R, C + 1, 1, attributes);// include up to and including current
break;
case 2:
deleteArea(0, 0, columns, rows, attributes);
break;
}
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " J");
break;
case '@':
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " @");
for (int i = 0; i < DCEvars[0]; i++)
insertChar(C, R, ' ', attributes);
break;
case 'X':
{
int toerase = DCEvars[0];
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " X, C=" + C + ",R=" + R);
if (toerase == 0)
toerase = 1;
if (toerase + C > columns)
toerase = columns - C;
deleteArea(C, R, toerase, 1, attributes);
// does not change cursor position
break;
}
case 'P':
if (debug > 1)
debug("ESC [ " + DCEvars[0] + " P, C=" + C + ",R=" + R);
if (DCEvars[0] == 0) DCEvars[0] = 1;
for (int i = 0; i < DCEvars[0]; i++)
deleteChar(C, R);
break;
case 'n':
switch (DCEvars[0]) {
case 5: /* malfunction? No malfunction. */
writeSpecial((ESC) + "[0n");
if (debug > 1)
debug("ESC[5n");
break;
case 6:
// DO NOT offset R and C by 1! (checked against /usr/X11R6/bin/resize
// FIXME check again.
// FIXME: but vttest thinks different???
writeSpecial((ESC) + "[" + R + ";" + C + "R");
if (debug > 1)
debug("ESC[6n");
break;
default:
if (debug > 0)
debug("ESC [ " + DCEvars[0] + " n??");
break;
}
break;
case 's': /* DECSC - save cursor */
Sc = C;
Sr = R;
Sa = attributes;
if (debug > 3)
debug("ESC[s");
break;
case 'u': /* DECRC - restore cursor */
C = Sc;
R = Sr;
attributes = Sa;
if (debug > 3)
debug("ESC[u");
break;
case 'm': /* attributes as color, bold , blink,*/
if (debug > 3)
debug("ESC [ ");
if (DCEvar == 0 && DCEvars[0] == 0)
attributes = 0;
for (int i = 0; i <= DCEvar; i++) {
switch (DCEvars[i]) {
case 0:
if (DCEvar > 0) {
if (terminalID.equals("scoansi")) {
attributes &= COLOR; /* Keeps color. Strange but true. */
} else {
attributes = 0;
}
}
break;
case 1:
attributes |= BOLD;
attributes &= ~LOW;
break;
case 2:
/* SCO color hack mode */
if (terminalID.equals("scoansi") && ((DCEvar - i) >= 2)) {
int ncolor;
attributes &= ~(COLOR | BOLD);
ncolor = DCEvars[i + 1];
if ((ncolor & 8) == 8)
attributes |= BOLD;
ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
attributes |= ((ncolor) + 1) << COLOR_FG_SHIFT;
ncolor = DCEvars[i + 2];
ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
attributes |= ((ncolor) + 1) << COLOR_BG_SHIFT;
i += 2;
} else {
attributes |= LOW;
}
break;
case 3: /* italics */
attributes |= INVERT;
break;
case 4:
attributes |= UNDERLINE;
break;
case 7:
attributes |= INVERT;
break;
case 8:
attributes |= INVISIBLE;
break;
case 5: /* blink on */
break;
/* 10 - ANSI X3.64-1979, select primary font, don't display control
* chars, don't set bit 8 on output */
case 10:
gl = 0;
usedcharsets = true;
break;
/* 11 - ANSI X3.64-1979, select second alt. font, display control
* chars, set bit 8 on output */
case 11: /* SMACS , as */
case 12:
gl = 1;
usedcharsets = true;
break;
case 21: /* normal intensity */
attributes &= ~(LOW | BOLD);
break;
case 23: /* italics off */
attributes &= ~INVERT;
break;
case 25: /* blinking off */
break;
case 27:
attributes &= ~INVERT;
break;
case 28:
attributes &= ~INVISIBLE;
break;
case 24:
attributes &= ~UNDERLINE;
break;
case 22:
attributes &= ~BOLD;
break;
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
attributes &= ~COLOR_FG;
attributes |= ((DCEvars[i] - 30) + 1)<< COLOR_FG_SHIFT;
break;
case 38:
if (DCEvars[i+1] == 5) {
attributes &= ~COLOR_FG;
attributes |= ((DCEvars[i + 2]) + 1) << COLOR_FG_SHIFT;
i += 2;
}
break;
case 39:
attributes &= ~COLOR_FG;
break;
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
attributes &= ~COLOR_BG;
attributes |= ((DCEvars[i] - 40) + 1) << COLOR_BG_SHIFT;
break;
case 48:
if (DCEvars[i+1] == 5) {
attributes &= ~COLOR_BG;
attributes |= (DCEvars[i + 2] + 1) << COLOR_BG_SHIFT;
i += 2;
}
break;
case 49:
attributes &= ~COLOR_BG;
break;
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
attributes &= ~COLOR_FG;
attributes |= ((DCEvars[i] - 82) + 1) << COLOR_FG_SHIFT;
break;
case 100:
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
attributes &= ~COLOR_BG;
attributes |= ((DCEvars[i] - 92) + 1) << COLOR_BG_SHIFT;
break;
default:
debugStr.append("ESC [ ")
.append(DCEvars[i])
.append(" m unknown...");
debug(debugStr.toString());
debugStr.setLength(0);
break;
}
if (debug > 3) {
debugStr.append(DCEvars[i])
.append(';');
debug(debugStr.toString());
debugStr.setLength(0);
}
}
if (debug > 3) {
debugStr.append(" (attributes = ")
.append(attributes)
.append(")m");
debug(debugStr.toString());
debugStr.setLength(0);
}
break;
default:
debugStr.append("ESC [ unknown letter: ")
.append(c)
.append(" (")
.append((int)c)
.append(')');
debug(debugStr.toString());
debugStr.setLength(0);
break;
}
break;
case TSTATE_TITLE:
switch (c) {
case ESC:
term_state = TSTATE_ESC;
break;
default:
// TODO save title
break;
}
break;
default:
term_state = TSTATE_DATA;
break;
}
setCursorPosition(C, R);
}
/* hard reset the terminal */
public void reset() {
gx[0] = 'B';
gx[1] = 'B';
gx[2] = 'B';
gx[3] = 'B';
gl = 0; // default GL to G0
gr = 2; // default GR to G2
onegl = -1; // Single shift override
/* reset tabs */
int nw = width;
if (nw < 132) nw = 132;
Tabs = new byte[nw];
for (int i = 0; i < nw; i += 8) {
Tabs[i] = 1;
}
deleteArea(0, 0, width, height, attributes);
setMargins(0, height);
C = R = 0;
_SetCursor(0, 0);
if (display != null)
display.resetColors();
showCursor(true);
/*FIXME:*/
term_state = TSTATE_DATA;
}
}
| Java |
/*
* This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
*
* (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
*
* Please visit http://javatelnet.org/ for updates and contact.
*
* --LICENSE NOTICE--
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* --LICENSE NOTICE--
*
*/
package de.mud.terminal;
/**
* Generic display
*/
public interface VDUDisplay {
public void redraw();
public void updateScrollBar();
public void setVDUBuffer(VDUBuffer buffer);
public VDUBuffer getVDUBuffer();
public void setColor(int index, int red, int green, int blue);
public void resetColors();
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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 de.mud.terminal;
/**
* @author Kenny Root
* This data was taken from xterm's precompose.c
*/
public class Precomposer {
public final static char precompositions[][] = {
{ 0x226E, 0x003C, 0x0338},
{ 0x2260, 0x003D, 0x0338},
{ 0x226F, 0x003E, 0x0338},
{ 0x00C0, 0x0041, 0x0300},
{ 0x00C1, 0x0041, 0x0301},
{ 0x00C2, 0x0041, 0x0302},
{ 0x00C3, 0x0041, 0x0303},
{ 0x0100, 0x0041, 0x0304},
{ 0x0102, 0x0041, 0x0306},
{ 0x0226, 0x0041, 0x0307},
{ 0x00C4, 0x0041, 0x0308},
{ 0x1EA2, 0x0041, 0x0309},
{ 0x00C5, 0x0041, 0x030A},
{ 0x01CD, 0x0041, 0x030C},
{ 0x0200, 0x0041, 0x030F},
{ 0x0202, 0x0041, 0x0311},
{ 0x1EA0, 0x0041, 0x0323},
{ 0x1E00, 0x0041, 0x0325},
{ 0x0104, 0x0041, 0x0328},
{ 0x1E02, 0x0042, 0x0307},
{ 0x1E04, 0x0042, 0x0323},
{ 0x1E06, 0x0042, 0x0331},
{ 0x0106, 0x0043, 0x0301},
{ 0x0108, 0x0043, 0x0302},
{ 0x010A, 0x0043, 0x0307},
{ 0x010C, 0x0043, 0x030C},
{ 0x00C7, 0x0043, 0x0327},
{ 0x1E0A, 0x0044, 0x0307},
{ 0x010E, 0x0044, 0x030C},
{ 0x1E0C, 0x0044, 0x0323},
{ 0x1E10, 0x0044, 0x0327},
{ 0x1E12, 0x0044, 0x032D},
{ 0x1E0E, 0x0044, 0x0331},
{ 0x00C8, 0x0045, 0x0300},
{ 0x00C9, 0x0045, 0x0301},
{ 0x00CA, 0x0045, 0x0302},
{ 0x1EBC, 0x0045, 0x0303},
{ 0x0112, 0x0045, 0x0304},
{ 0x0114, 0x0045, 0x0306},
{ 0x0116, 0x0045, 0x0307},
{ 0x00CB, 0x0045, 0x0308},
{ 0x1EBA, 0x0045, 0x0309},
{ 0x011A, 0x0045, 0x030C},
{ 0x0204, 0x0045, 0x030F},
{ 0x0206, 0x0045, 0x0311},
{ 0x1EB8, 0x0045, 0x0323},
{ 0x0228, 0x0045, 0x0327},
{ 0x0118, 0x0045, 0x0328},
{ 0x1E18, 0x0045, 0x032D},
{ 0x1E1A, 0x0045, 0x0330},
{ 0x1E1E, 0x0046, 0x0307},
{ 0x01F4, 0x0047, 0x0301},
{ 0x011C, 0x0047, 0x0302},
{ 0x1E20, 0x0047, 0x0304},
{ 0x011E, 0x0047, 0x0306},
{ 0x0120, 0x0047, 0x0307},
{ 0x01E6, 0x0047, 0x030C},
{ 0x0122, 0x0047, 0x0327},
{ 0x0124, 0x0048, 0x0302},
{ 0x1E22, 0x0048, 0x0307},
{ 0x1E26, 0x0048, 0x0308},
{ 0x021E, 0x0048, 0x030C},
{ 0x1E24, 0x0048, 0x0323},
{ 0x1E28, 0x0048, 0x0327},
{ 0x1E2A, 0x0048, 0x032E},
{ 0x00CC, 0x0049, 0x0300},
{ 0x00CD, 0x0049, 0x0301},
{ 0x00CE, 0x0049, 0x0302},
{ 0x0128, 0x0049, 0x0303},
{ 0x012A, 0x0049, 0x0304},
{ 0x012C, 0x0049, 0x0306},
{ 0x0130, 0x0049, 0x0307},
{ 0x00CF, 0x0049, 0x0308},
{ 0x1EC8, 0x0049, 0x0309},
{ 0x01CF, 0x0049, 0x030C},
{ 0x0208, 0x0049, 0x030F},
{ 0x020A, 0x0049, 0x0311},
{ 0x1ECA, 0x0049, 0x0323},
{ 0x012E, 0x0049, 0x0328},
{ 0x1E2C, 0x0049, 0x0330},
{ 0x0134, 0x004A, 0x0302},
{ 0x1E30, 0x004B, 0x0301},
{ 0x01E8, 0x004B, 0x030C},
{ 0x1E32, 0x004B, 0x0323},
{ 0x0136, 0x004B, 0x0327},
{ 0x1E34, 0x004B, 0x0331},
{ 0x0139, 0x004C, 0x0301},
{ 0x013D, 0x004C, 0x030C},
{ 0x1E36, 0x004C, 0x0323},
{ 0x013B, 0x004C, 0x0327},
{ 0x1E3C, 0x004C, 0x032D},
{ 0x1E3A, 0x004C, 0x0331},
{ 0x1E3E, 0x004D, 0x0301},
{ 0x1E40, 0x004D, 0x0307},
{ 0x1E42, 0x004D, 0x0323},
{ 0x01F8, 0x004E, 0x0300},
{ 0x0143, 0x004E, 0x0301},
{ 0x00D1, 0x004E, 0x0303},
{ 0x1E44, 0x004E, 0x0307},
{ 0x0147, 0x004E, 0x030C},
{ 0x1E46, 0x004E, 0x0323},
{ 0x0145, 0x004E, 0x0327},
{ 0x1E4A, 0x004E, 0x032D},
{ 0x1E48, 0x004E, 0x0331},
{ 0x00D2, 0x004F, 0x0300},
{ 0x00D3, 0x004F, 0x0301},
{ 0x00D4, 0x004F, 0x0302},
{ 0x00D5, 0x004F, 0x0303},
{ 0x014C, 0x004F, 0x0304},
{ 0x014E, 0x004F, 0x0306},
{ 0x022E, 0x004F, 0x0307},
{ 0x00D6, 0x004F, 0x0308},
{ 0x1ECE, 0x004F, 0x0309},
{ 0x0150, 0x004F, 0x030B},
{ 0x01D1, 0x004F, 0x030C},
{ 0x020C, 0x004F, 0x030F},
{ 0x020E, 0x004F, 0x0311},
{ 0x01A0, 0x004F, 0x031B},
{ 0x1ECC, 0x004F, 0x0323},
{ 0x01EA, 0x004F, 0x0328},
{ 0x1E54, 0x0050, 0x0301},
{ 0x1E56, 0x0050, 0x0307},
{ 0x0154, 0x0052, 0x0301},
{ 0x1E58, 0x0052, 0x0307},
{ 0x0158, 0x0052, 0x030C},
{ 0x0210, 0x0052, 0x030F},
{ 0x0212, 0x0052, 0x0311},
{ 0x1E5A, 0x0052, 0x0323},
{ 0x0156, 0x0052, 0x0327},
{ 0x1E5E, 0x0052, 0x0331},
{ 0x015A, 0x0053, 0x0301},
{ 0x015C, 0x0053, 0x0302},
{ 0x1E60, 0x0053, 0x0307},
{ 0x0160, 0x0053, 0x030C},
{ 0x1E62, 0x0053, 0x0323},
{ 0x0218, 0x0053, 0x0326},
{ 0x015E, 0x0053, 0x0327},
{ 0x1E6A, 0x0054, 0x0307},
{ 0x0164, 0x0054, 0x030C},
{ 0x1E6C, 0x0054, 0x0323},
{ 0x021A, 0x0054, 0x0326},
{ 0x0162, 0x0054, 0x0327},
{ 0x1E70, 0x0054, 0x032D},
{ 0x1E6E, 0x0054, 0x0331},
{ 0x00D9, 0x0055, 0x0300},
{ 0x00DA, 0x0055, 0x0301},
{ 0x00DB, 0x0055, 0x0302},
{ 0x0168, 0x0055, 0x0303},
{ 0x016A, 0x0055, 0x0304},
{ 0x016C, 0x0055, 0x0306},
{ 0x00DC, 0x0055, 0x0308},
{ 0x1EE6, 0x0055, 0x0309},
{ 0x016E, 0x0055, 0x030A},
{ 0x0170, 0x0055, 0x030B},
{ 0x01D3, 0x0055, 0x030C},
{ 0x0214, 0x0055, 0x030F},
{ 0x0216, 0x0055, 0x0311},
{ 0x01AF, 0x0055, 0x031B},
{ 0x1EE4, 0x0055, 0x0323},
{ 0x1E72, 0x0055, 0x0324},
{ 0x0172, 0x0055, 0x0328},
{ 0x1E76, 0x0055, 0x032D},
{ 0x1E74, 0x0055, 0x0330},
{ 0x1E7C, 0x0056, 0x0303},
{ 0x1E7E, 0x0056, 0x0323},
{ 0x1E80, 0x0057, 0x0300},
{ 0x1E82, 0x0057, 0x0301},
{ 0x0174, 0x0057, 0x0302},
{ 0x1E86, 0x0057, 0x0307},
{ 0x1E84, 0x0057, 0x0308},
{ 0x1E88, 0x0057, 0x0323},
{ 0x1E8A, 0x0058, 0x0307},
{ 0x1E8C, 0x0058, 0x0308},
{ 0x1EF2, 0x0059, 0x0300},
{ 0x00DD, 0x0059, 0x0301},
{ 0x0176, 0x0059, 0x0302},
{ 0x1EF8, 0x0059, 0x0303},
{ 0x0232, 0x0059, 0x0304},
{ 0x1E8E, 0x0059, 0x0307},
{ 0x0178, 0x0059, 0x0308},
{ 0x1EF6, 0x0059, 0x0309},
{ 0x1EF4, 0x0059, 0x0323},
{ 0x0179, 0x005A, 0x0301},
{ 0x1E90, 0x005A, 0x0302},
{ 0x017B, 0x005A, 0x0307},
{ 0x017D, 0x005A, 0x030C},
{ 0x1E92, 0x005A, 0x0323},
{ 0x1E94, 0x005A, 0x0331},
{ 0x00E0, 0x0061, 0x0300},
{ 0x00E1, 0x0061, 0x0301},
{ 0x00E2, 0x0061, 0x0302},
{ 0x00E3, 0x0061, 0x0303},
{ 0x0101, 0x0061, 0x0304},
{ 0x0103, 0x0061, 0x0306},
{ 0x0227, 0x0061, 0x0307},
{ 0x00E4, 0x0061, 0x0308},
{ 0x1EA3, 0x0061, 0x0309},
{ 0x00E5, 0x0061, 0x030A},
{ 0x01CE, 0x0061, 0x030C},
{ 0x0201, 0x0061, 0x030F},
{ 0x0203, 0x0061, 0x0311},
{ 0x1EA1, 0x0061, 0x0323},
{ 0x1E01, 0x0061, 0x0325},
{ 0x0105, 0x0061, 0x0328},
{ 0x1E03, 0x0062, 0x0307},
{ 0x1E05, 0x0062, 0x0323},
{ 0x1E07, 0x0062, 0x0331},
{ 0x0107, 0x0063, 0x0301},
{ 0x0109, 0x0063, 0x0302},
{ 0x010B, 0x0063, 0x0307},
{ 0x010D, 0x0063, 0x030C},
{ 0x00E7, 0x0063, 0x0327},
{ 0x1E0B, 0x0064, 0x0307},
{ 0x010F, 0x0064, 0x030C},
{ 0x1E0D, 0x0064, 0x0323},
{ 0x1E11, 0x0064, 0x0327},
{ 0x1E13, 0x0064, 0x032D},
{ 0x1E0F, 0x0064, 0x0331},
{ 0x00E8, 0x0065, 0x0300},
{ 0x00E9, 0x0065, 0x0301},
{ 0x00EA, 0x0065, 0x0302},
{ 0x1EBD, 0x0065, 0x0303},
{ 0x0113, 0x0065, 0x0304},
{ 0x0115, 0x0065, 0x0306},
{ 0x0117, 0x0065, 0x0307},
{ 0x00EB, 0x0065, 0x0308},
{ 0x1EBB, 0x0065, 0x0309},
{ 0x011B, 0x0065, 0x030C},
{ 0x0205, 0x0065, 0x030F},
{ 0x0207, 0x0065, 0x0311},
{ 0x1EB9, 0x0065, 0x0323},
{ 0x0229, 0x0065, 0x0327},
{ 0x0119, 0x0065, 0x0328},
{ 0x1E19, 0x0065, 0x032D},
{ 0x1E1B, 0x0065, 0x0330},
{ 0x1E1F, 0x0066, 0x0307},
{ 0x01F5, 0x0067, 0x0301},
{ 0x011D, 0x0067, 0x0302},
{ 0x1E21, 0x0067, 0x0304},
{ 0x011F, 0x0067, 0x0306},
{ 0x0121, 0x0067, 0x0307},
{ 0x01E7, 0x0067, 0x030C},
{ 0x0123, 0x0067, 0x0327},
{ 0x0125, 0x0068, 0x0302},
{ 0x1E23, 0x0068, 0x0307},
{ 0x1E27, 0x0068, 0x0308},
{ 0x021F, 0x0068, 0x030C},
{ 0x1E25, 0x0068, 0x0323},
{ 0x1E29, 0x0068, 0x0327},
{ 0x1E2B, 0x0068, 0x032E},
{ 0x1E96, 0x0068, 0x0331},
{ 0x00EC, 0x0069, 0x0300},
{ 0x00ED, 0x0069, 0x0301},
{ 0x00EE, 0x0069, 0x0302},
{ 0x0129, 0x0069, 0x0303},
{ 0x012B, 0x0069, 0x0304},
{ 0x012D, 0x0069, 0x0306},
{ 0x00EF, 0x0069, 0x0308},
{ 0x1EC9, 0x0069, 0x0309},
{ 0x01D0, 0x0069, 0x030C},
{ 0x0209, 0x0069, 0x030F},
{ 0x020B, 0x0069, 0x0311},
{ 0x1ECB, 0x0069, 0x0323},
{ 0x012F, 0x0069, 0x0328},
{ 0x1E2D, 0x0069, 0x0330},
{ 0x0135, 0x006A, 0x0302},
{ 0x01F0, 0x006A, 0x030C},
{ 0x1E31, 0x006B, 0x0301},
{ 0x01E9, 0x006B, 0x030C},
{ 0x1E33, 0x006B, 0x0323},
{ 0x0137, 0x006B, 0x0327},
{ 0x1E35, 0x006B, 0x0331},
{ 0x013A, 0x006C, 0x0301},
{ 0x013E, 0x006C, 0x030C},
{ 0x1E37, 0x006C, 0x0323},
{ 0x013C, 0x006C, 0x0327},
{ 0x1E3D, 0x006C, 0x032D},
{ 0x1E3B, 0x006C, 0x0331},
{ 0x1E3F, 0x006D, 0x0301},
{ 0x1E41, 0x006D, 0x0307},
{ 0x1E43, 0x006D, 0x0323},
{ 0x01F9, 0x006E, 0x0300},
{ 0x0144, 0x006E, 0x0301},
{ 0x00F1, 0x006E, 0x0303},
{ 0x1E45, 0x006E, 0x0307},
{ 0x0148, 0x006E, 0x030C},
{ 0x1E47, 0x006E, 0x0323},
{ 0x0146, 0x006E, 0x0327},
{ 0x1E4B, 0x006E, 0x032D},
{ 0x1E49, 0x006E, 0x0331},
{ 0x00F2, 0x006F, 0x0300},
{ 0x00F3, 0x006F, 0x0301},
{ 0x00F4, 0x006F, 0x0302},
{ 0x00F5, 0x006F, 0x0303},
{ 0x014D, 0x006F, 0x0304},
{ 0x014F, 0x006F, 0x0306},
{ 0x022F, 0x006F, 0x0307},
{ 0x00F6, 0x006F, 0x0308},
{ 0x1ECF, 0x006F, 0x0309},
{ 0x0151, 0x006F, 0x030B},
{ 0x01D2, 0x006F, 0x030C},
{ 0x020D, 0x006F, 0x030F},
{ 0x020F, 0x006F, 0x0311},
{ 0x01A1, 0x006F, 0x031B},
{ 0x1ECD, 0x006F, 0x0323},
{ 0x01EB, 0x006F, 0x0328},
{ 0x1E55, 0x0070, 0x0301},
{ 0x1E57, 0x0070, 0x0307},
{ 0x0155, 0x0072, 0x0301},
{ 0x1E59, 0x0072, 0x0307},
{ 0x0159, 0x0072, 0x030C},
{ 0x0211, 0x0072, 0x030F},
{ 0x0213, 0x0072, 0x0311},
{ 0x1E5B, 0x0072, 0x0323},
{ 0x0157, 0x0072, 0x0327},
{ 0x1E5F, 0x0072, 0x0331},
{ 0x015B, 0x0073, 0x0301},
{ 0x015D, 0x0073, 0x0302},
{ 0x1E61, 0x0073, 0x0307},
{ 0x0161, 0x0073, 0x030C},
{ 0x1E63, 0x0073, 0x0323},
{ 0x0219, 0x0073, 0x0326},
{ 0x015F, 0x0073, 0x0327},
{ 0x1E6B, 0x0074, 0x0307},
{ 0x1E97, 0x0074, 0x0308},
{ 0x0165, 0x0074, 0x030C},
{ 0x1E6D, 0x0074, 0x0323},
{ 0x021B, 0x0074, 0x0326},
{ 0x0163, 0x0074, 0x0327},
{ 0x1E71, 0x0074, 0x032D},
{ 0x1E6F, 0x0074, 0x0331},
{ 0x00F9, 0x0075, 0x0300},
{ 0x00FA, 0x0075, 0x0301},
{ 0x00FB, 0x0075, 0x0302},
{ 0x0169, 0x0075, 0x0303},
{ 0x016B, 0x0075, 0x0304},
{ 0x016D, 0x0075, 0x0306},
{ 0x00FC, 0x0075, 0x0308},
{ 0x1EE7, 0x0075, 0x0309},
{ 0x016F, 0x0075, 0x030A},
{ 0x0171, 0x0075, 0x030B},
{ 0x01D4, 0x0075, 0x030C},
{ 0x0215, 0x0075, 0x030F},
{ 0x0217, 0x0075, 0x0311},
{ 0x01B0, 0x0075, 0x031B},
{ 0x1EE5, 0x0075, 0x0323},
{ 0x1E73, 0x0075, 0x0324},
{ 0x0173, 0x0075, 0x0328},
{ 0x1E77, 0x0075, 0x032D},
{ 0x1E75, 0x0075, 0x0330},
{ 0x1E7D, 0x0076, 0x0303},
{ 0x1E7F, 0x0076, 0x0323},
{ 0x1E81, 0x0077, 0x0300},
{ 0x1E83, 0x0077, 0x0301},
{ 0x0175, 0x0077, 0x0302},
{ 0x1E87, 0x0077, 0x0307},
{ 0x1E85, 0x0077, 0x0308},
{ 0x1E98, 0x0077, 0x030A},
{ 0x1E89, 0x0077, 0x0323},
{ 0x1E8B, 0x0078, 0x0307},
{ 0x1E8D, 0x0078, 0x0308},
{ 0x1EF3, 0x0079, 0x0300},
{ 0x00FD, 0x0079, 0x0301},
{ 0x0177, 0x0079, 0x0302},
{ 0x1EF9, 0x0079, 0x0303},
{ 0x0233, 0x0079, 0x0304},
{ 0x1E8F, 0x0079, 0x0307},
{ 0x00FF, 0x0079, 0x0308},
{ 0x1EF7, 0x0079, 0x0309},
{ 0x1E99, 0x0079, 0x030A},
{ 0x1EF5, 0x0079, 0x0323},
{ 0x017A, 0x007A, 0x0301},
{ 0x1E91, 0x007A, 0x0302},
{ 0x017C, 0x007A, 0x0307},
{ 0x017E, 0x007A, 0x030C},
{ 0x1E93, 0x007A, 0x0323},
{ 0x1E95, 0x007A, 0x0331},
{ 0x1FED, 0x00A8, 0x0300},
{ 0x0385, 0x00A8, 0x0301},
{ 0x1FC1, 0x00A8, 0x0342},
{ 0x1EA6, 0x00C2, 0x0300},
{ 0x1EA4, 0x00C2, 0x0301},
{ 0x1EAA, 0x00C2, 0x0303},
{ 0x1EA8, 0x00C2, 0x0309},
{ 0x01DE, 0x00C4, 0x0304},
{ 0x01FA, 0x00C5, 0x0301},
{ 0x01FC, 0x00C6, 0x0301},
{ 0x01E2, 0x00C6, 0x0304},
{ 0x1E08, 0x00C7, 0x0301},
{ 0x1EC0, 0x00CA, 0x0300},
{ 0x1EBE, 0x00CA, 0x0301},
{ 0x1EC4, 0x00CA, 0x0303},
{ 0x1EC2, 0x00CA, 0x0309},
{ 0x1E2E, 0x00CF, 0x0301},
{ 0x1ED2, 0x00D4, 0x0300},
{ 0x1ED0, 0x00D4, 0x0301},
{ 0x1ED6, 0x00D4, 0x0303},
{ 0x1ED4, 0x00D4, 0x0309},
{ 0x1E4C, 0x00D5, 0x0301},
{ 0x022C, 0x00D5, 0x0304},
{ 0x1E4E, 0x00D5, 0x0308},
{ 0x022A, 0x00D6, 0x0304},
{ 0x01FE, 0x00D8, 0x0301},
{ 0x01DB, 0x00DC, 0x0300},
{ 0x01D7, 0x00DC, 0x0301},
{ 0x01D5, 0x00DC, 0x0304},
{ 0x01D9, 0x00DC, 0x030C},
{ 0x1EA7, 0x00E2, 0x0300},
{ 0x1EA5, 0x00E2, 0x0301},
{ 0x1EAB, 0x00E2, 0x0303},
{ 0x1EA9, 0x00E2, 0x0309},
{ 0x01DF, 0x00E4, 0x0304},
{ 0x01FB, 0x00E5, 0x0301},
{ 0x01FD, 0x00E6, 0x0301},
{ 0x01E3, 0x00E6, 0x0304},
{ 0x1E09, 0x00E7, 0x0301},
{ 0x1EC1, 0x00EA, 0x0300},
{ 0x1EBF, 0x00EA, 0x0301},
{ 0x1EC5, 0x00EA, 0x0303},
{ 0x1EC3, 0x00EA, 0x0309},
{ 0x1E2F, 0x00EF, 0x0301},
{ 0x1ED3, 0x00F4, 0x0300},
{ 0x1ED1, 0x00F4, 0x0301},
{ 0x1ED7, 0x00F4, 0x0303},
{ 0x1ED5, 0x00F4, 0x0309},
{ 0x1E4D, 0x00F5, 0x0301},
{ 0x022D, 0x00F5, 0x0304},
{ 0x1E4F, 0x00F5, 0x0308},
{ 0x022B, 0x00F6, 0x0304},
{ 0x01FF, 0x00F8, 0x0301},
{ 0x01DC, 0x00FC, 0x0300},
{ 0x01D8, 0x00FC, 0x0301},
{ 0x01D6, 0x00FC, 0x0304},
{ 0x01DA, 0x00FC, 0x030C},
{ 0x1EB0, 0x0102, 0x0300},
{ 0x1EAE, 0x0102, 0x0301},
{ 0x1EB4, 0x0102, 0x0303},
{ 0x1EB2, 0x0102, 0x0309},
{ 0x1EB1, 0x0103, 0x0300},
{ 0x1EAF, 0x0103, 0x0301},
{ 0x1EB5, 0x0103, 0x0303},
{ 0x1EB3, 0x0103, 0x0309},
{ 0x1E14, 0x0112, 0x0300},
{ 0x1E16, 0x0112, 0x0301},
{ 0x1E15, 0x0113, 0x0300},
{ 0x1E17, 0x0113, 0x0301},
{ 0x1E50, 0x014C, 0x0300},
{ 0x1E52, 0x014C, 0x0301},
{ 0x1E51, 0x014D, 0x0300},
{ 0x1E53, 0x014D, 0x0301},
{ 0x1E64, 0x015A, 0x0307},
{ 0x1E65, 0x015B, 0x0307},
{ 0x1E66, 0x0160, 0x0307},
{ 0x1E67, 0x0161, 0x0307},
{ 0x1E78, 0x0168, 0x0301},
{ 0x1E79, 0x0169, 0x0301},
{ 0x1E7A, 0x016A, 0x0308},
{ 0x1E7B, 0x016B, 0x0308},
{ 0x1E9B, 0x017F, 0x0307},
{ 0x1EDC, 0x01A0, 0x0300},
{ 0x1EDA, 0x01A0, 0x0301},
{ 0x1EE0, 0x01A0, 0x0303},
{ 0x1EDE, 0x01A0, 0x0309},
{ 0x1EE2, 0x01A0, 0x0323},
{ 0x1EDD, 0x01A1, 0x0300},
{ 0x1EDB, 0x01A1, 0x0301},
{ 0x1EE1, 0x01A1, 0x0303},
{ 0x1EDF, 0x01A1, 0x0309},
{ 0x1EE3, 0x01A1, 0x0323},
{ 0x1EEA, 0x01AF, 0x0300},
{ 0x1EE8, 0x01AF, 0x0301},
{ 0x1EEE, 0x01AF, 0x0303},
{ 0x1EEC, 0x01AF, 0x0309},
{ 0x1EF0, 0x01AF, 0x0323},
{ 0x1EEB, 0x01B0, 0x0300},
{ 0x1EE9, 0x01B0, 0x0301},
{ 0x1EEF, 0x01B0, 0x0303},
{ 0x1EED, 0x01B0, 0x0309},
{ 0x1EF1, 0x01B0, 0x0323},
{ 0x01EE, 0x01B7, 0x030C},
{ 0x01EC, 0x01EA, 0x0304},
{ 0x01ED, 0x01EB, 0x0304},
{ 0x01E0, 0x0226, 0x0304},
{ 0x01E1, 0x0227, 0x0304},
{ 0x1E1C, 0x0228, 0x0306},
{ 0x1E1D, 0x0229, 0x0306},
{ 0x0230, 0x022E, 0x0304},
{ 0x0231, 0x022F, 0x0304},
{ 0x01EF, 0x0292, 0x030C},
{ 0x0344, 0x0308, 0x0301},
{ 0x1FBA, 0x0391, 0x0300},
{ 0x0386, 0x0391, 0x0301},
{ 0x1FB9, 0x0391, 0x0304},
{ 0x1FB8, 0x0391, 0x0306},
{ 0x1F08, 0x0391, 0x0313},
{ 0x1F09, 0x0391, 0x0314},
{ 0x1FBC, 0x0391, 0x0345},
{ 0x1FC8, 0x0395, 0x0300},
{ 0x0388, 0x0395, 0x0301},
{ 0x1F18, 0x0395, 0x0313},
{ 0x1F19, 0x0395, 0x0314},
{ 0x1FCA, 0x0397, 0x0300},
{ 0x0389, 0x0397, 0x0301},
{ 0x1F28, 0x0397, 0x0313},
{ 0x1F29, 0x0397, 0x0314},
{ 0x1FCC, 0x0397, 0x0345},
{ 0x1FDA, 0x0399, 0x0300},
{ 0x038A, 0x0399, 0x0301},
{ 0x1FD9, 0x0399, 0x0304},
{ 0x1FD8, 0x0399, 0x0306},
{ 0x03AA, 0x0399, 0x0308},
{ 0x1F38, 0x0399, 0x0313},
{ 0x1F39, 0x0399, 0x0314},
{ 0x1FF8, 0x039F, 0x0300},
{ 0x038C, 0x039F, 0x0301},
{ 0x1F48, 0x039F, 0x0313},
{ 0x1F49, 0x039F, 0x0314},
{ 0x1FEC, 0x03A1, 0x0314},
{ 0x1FEA, 0x03A5, 0x0300},
{ 0x038E, 0x03A5, 0x0301},
{ 0x1FE9, 0x03A5, 0x0304},
{ 0x1FE8, 0x03A5, 0x0306},
{ 0x03AB, 0x03A5, 0x0308},
{ 0x1F59, 0x03A5, 0x0314},
{ 0x1FFA, 0x03A9, 0x0300},
{ 0x038F, 0x03A9, 0x0301},
{ 0x1F68, 0x03A9, 0x0313},
{ 0x1F69, 0x03A9, 0x0314},
{ 0x1FFC, 0x03A9, 0x0345},
{ 0x1FB4, 0x03AC, 0x0345},
{ 0x1FC4, 0x03AE, 0x0345},
{ 0x1F70, 0x03B1, 0x0300},
{ 0x03AC, 0x03B1, 0x0301},
{ 0x1FB1, 0x03B1, 0x0304},
{ 0x1FB0, 0x03B1, 0x0306},
{ 0x1F00, 0x03B1, 0x0313},
{ 0x1F01, 0x03B1, 0x0314},
{ 0x1FB6, 0x03B1, 0x0342},
{ 0x1FB3, 0x03B1, 0x0345},
{ 0x1F72, 0x03B5, 0x0300},
{ 0x03AD, 0x03B5, 0x0301},
{ 0x1F10, 0x03B5, 0x0313},
{ 0x1F11, 0x03B5, 0x0314},
{ 0x1F74, 0x03B7, 0x0300},
{ 0x03AE, 0x03B7, 0x0301},
{ 0x1F20, 0x03B7, 0x0313},
{ 0x1F21, 0x03B7, 0x0314},
{ 0x1FC6, 0x03B7, 0x0342},
{ 0x1FC3, 0x03B7, 0x0345},
{ 0x1F76, 0x03B9, 0x0300},
{ 0x03AF, 0x03B9, 0x0301},
{ 0x1FD1, 0x03B9, 0x0304},
{ 0x1FD0, 0x03B9, 0x0306},
{ 0x03CA, 0x03B9, 0x0308},
{ 0x1F30, 0x03B9, 0x0313},
{ 0x1F31, 0x03B9, 0x0314},
{ 0x1FD6, 0x03B9, 0x0342},
{ 0x1F78, 0x03BF, 0x0300},
{ 0x03CC, 0x03BF, 0x0301},
{ 0x1F40, 0x03BF, 0x0313},
{ 0x1F41, 0x03BF, 0x0314},
{ 0x1FE4, 0x03C1, 0x0313},
{ 0x1FE5, 0x03C1, 0x0314},
{ 0x1F7A, 0x03C5, 0x0300},
{ 0x03CD, 0x03C5, 0x0301},
{ 0x1FE1, 0x03C5, 0x0304},
{ 0x1FE0, 0x03C5, 0x0306},
{ 0x03CB, 0x03C5, 0x0308},
{ 0x1F50, 0x03C5, 0x0313},
{ 0x1F51, 0x03C5, 0x0314},
{ 0x1FE6, 0x03C5, 0x0342},
{ 0x1F7C, 0x03C9, 0x0300},
{ 0x03CE, 0x03C9, 0x0301},
{ 0x1F60, 0x03C9, 0x0313},
{ 0x1F61, 0x03C9, 0x0314},
{ 0x1FF6, 0x03C9, 0x0342},
{ 0x1FF3, 0x03C9, 0x0345},
{ 0x1FD2, 0x03CA, 0x0300},
{ 0x0390, 0x03CA, 0x0301},
{ 0x1FD7, 0x03CA, 0x0342},
{ 0x1FE2, 0x03CB, 0x0300},
{ 0x03B0, 0x03CB, 0x0301},
{ 0x1FE7, 0x03CB, 0x0342},
{ 0x1FF4, 0x03CE, 0x0345},
{ 0x03D3, 0x03D2, 0x0301},
{ 0x03D4, 0x03D2, 0x0308},
{ 0x0407, 0x0406, 0x0308},
{ 0x04D0, 0x0410, 0x0306},
{ 0x04D2, 0x0410, 0x0308},
{ 0x0403, 0x0413, 0x0301},
{ 0x0400, 0x0415, 0x0300},
{ 0x04D6, 0x0415, 0x0306},
{ 0x0401, 0x0415, 0x0308},
{ 0x04C1, 0x0416, 0x0306},
{ 0x04DC, 0x0416, 0x0308},
{ 0x04DE, 0x0417, 0x0308},
{ 0x040D, 0x0418, 0x0300},
{ 0x04E2, 0x0418, 0x0304},
{ 0x0419, 0x0418, 0x0306},
{ 0x04E4, 0x0418, 0x0308},
{ 0x040C, 0x041A, 0x0301},
{ 0x04E6, 0x041E, 0x0308},
{ 0x04EE, 0x0423, 0x0304},
{ 0x040E, 0x0423, 0x0306},
{ 0x04F0, 0x0423, 0x0308},
{ 0x04F2, 0x0423, 0x030B},
{ 0x04F4, 0x0427, 0x0308},
{ 0x04F8, 0x042B, 0x0308},
{ 0x04EC, 0x042D, 0x0308},
{ 0x04D1, 0x0430, 0x0306},
{ 0x04D3, 0x0430, 0x0308},
{ 0x0453, 0x0433, 0x0301},
{ 0x0450, 0x0435, 0x0300},
{ 0x04D7, 0x0435, 0x0306},
{ 0x0451, 0x0435, 0x0308},
{ 0x04C2, 0x0436, 0x0306},
{ 0x04DD, 0x0436, 0x0308},
{ 0x04DF, 0x0437, 0x0308},
{ 0x045D, 0x0438, 0x0300},
{ 0x04E3, 0x0438, 0x0304},
{ 0x0439, 0x0438, 0x0306},
{ 0x04E5, 0x0438, 0x0308},
{ 0x045C, 0x043A, 0x0301},
{ 0x04E7, 0x043E, 0x0308},
{ 0x04EF, 0x0443, 0x0304},
{ 0x045E, 0x0443, 0x0306},
{ 0x04F1, 0x0443, 0x0308},
{ 0x04F3, 0x0443, 0x030B},
{ 0x04F5, 0x0447, 0x0308},
{ 0x04F9, 0x044B, 0x0308},
{ 0x04ED, 0x044D, 0x0308},
{ 0x0457, 0x0456, 0x0308},
{ 0x0476, 0x0474, 0x030F},
{ 0x0477, 0x0475, 0x030F},
{ 0x04DA, 0x04D8, 0x0308},
{ 0x04DB, 0x04D9, 0x0308},
{ 0x04EA, 0x04E8, 0x0308},
{ 0x04EB, 0x04E9, 0x0308},
{ 0xFB2E, 0x05D0, 0x05B7},
{ 0xFB2F, 0x05D0, 0x05B8},
{ 0xFB30, 0x05D0, 0x05BC},
{ 0xFB31, 0x05D1, 0x05BC},
{ 0xFB4C, 0x05D1, 0x05BF},
{ 0xFB32, 0x05D2, 0x05BC},
{ 0xFB33, 0x05D3, 0x05BC},
{ 0xFB34, 0x05D4, 0x05BC},
{ 0xFB4B, 0x05D5, 0x05B9},
{ 0xFB35, 0x05D5, 0x05BC},
{ 0xFB36, 0x05D6, 0x05BC},
{ 0xFB38, 0x05D8, 0x05BC},
{ 0xFB1D, 0x05D9, 0x05B4},
{ 0xFB39, 0x05D9, 0x05BC},
{ 0xFB3A, 0x05DA, 0x05BC},
{ 0xFB3B, 0x05DB, 0x05BC},
{ 0xFB4D, 0x05DB, 0x05BF},
{ 0xFB3C, 0x05DC, 0x05BC},
{ 0xFB3E, 0x05DE, 0x05BC},
{ 0xFB40, 0x05E0, 0x05BC},
{ 0xFB41, 0x05E1, 0x05BC},
{ 0xFB43, 0x05E3, 0x05BC},
{ 0xFB44, 0x05E4, 0x05BC},
{ 0xFB4E, 0x05E4, 0x05BF},
{ 0xFB46, 0x05E6, 0x05BC},
{ 0xFB47, 0x05E7, 0x05BC},
{ 0xFB48, 0x05E8, 0x05BC},
{ 0xFB49, 0x05E9, 0x05BC},
{ 0xFB2A, 0x05E9, 0x05C1},
{ 0xFB2B, 0x05E9, 0x05C2},
{ 0xFB4A, 0x05EA, 0x05BC},
{ 0xFB1F, 0x05F2, 0x05B7},
{ 0x0622, 0x0627, 0x0653},
{ 0x0623, 0x0627, 0x0654},
{ 0x0625, 0x0627, 0x0655},
{ 0x0624, 0x0648, 0x0654},
{ 0x0626, 0x064A, 0x0654},
{ 0x06C2, 0x06C1, 0x0654},
{ 0x06D3, 0x06D2, 0x0654},
{ 0x06C0, 0x06D5, 0x0654},
{ 0x0958, 0x0915, 0x093C},
{ 0x0959, 0x0916, 0x093C},
{ 0x095A, 0x0917, 0x093C},
{ 0x095B, 0x091C, 0x093C},
{ 0x095C, 0x0921, 0x093C},
{ 0x095D, 0x0922, 0x093C},
{ 0x0929, 0x0928, 0x093C},
{ 0x095E, 0x092B, 0x093C},
{ 0x095F, 0x092F, 0x093C},
{ 0x0931, 0x0930, 0x093C},
{ 0x0934, 0x0933, 0x093C},
{ 0x09DC, 0x09A1, 0x09BC},
{ 0x09DD, 0x09A2, 0x09BC},
{ 0x09DF, 0x09AF, 0x09BC},
{ 0x09CB, 0x09C7, 0x09BE},
{ 0x09CC, 0x09C7, 0x09D7},
{ 0x0A59, 0x0A16, 0x0A3C},
{ 0x0A5A, 0x0A17, 0x0A3C},
{ 0x0A5B, 0x0A1C, 0x0A3C},
{ 0x0A5E, 0x0A2B, 0x0A3C},
{ 0x0A33, 0x0A32, 0x0A3C},
{ 0x0A36, 0x0A38, 0x0A3C},
{ 0x0B5C, 0x0B21, 0x0B3C},
{ 0x0B5D, 0x0B22, 0x0B3C},
{ 0x0B4B, 0x0B47, 0x0B3E},
{ 0x0B48, 0x0B47, 0x0B56},
{ 0x0B4C, 0x0B47, 0x0B57},
{ 0x0B94, 0x0B92, 0x0BD7},
{ 0x0BCA, 0x0BC6, 0x0BBE},
{ 0x0BCC, 0x0BC6, 0x0BD7},
{ 0x0BCB, 0x0BC7, 0x0BBE},
{ 0x0C48, 0x0C46, 0x0C56},
{ 0x0CC0, 0x0CBF, 0x0CD5},
{ 0x0CCA, 0x0CC6, 0x0CC2},
{ 0x0CC7, 0x0CC6, 0x0CD5},
{ 0x0CC8, 0x0CC6, 0x0CD6},
{ 0x0CCB, 0x0CCA, 0x0CD5},
{ 0x0D4A, 0x0D46, 0x0D3E},
{ 0x0D4C, 0x0D46, 0x0D57},
{ 0x0D4B, 0x0D47, 0x0D3E},
{ 0x0DDA, 0x0DD9, 0x0DCA},
{ 0x0DDC, 0x0DD9, 0x0DCF},
{ 0x0DDE, 0x0DD9, 0x0DDF},
{ 0x0DDD, 0x0DDC, 0x0DCA},
{ 0x0F69, 0x0F40, 0x0FB5},
{ 0x0F43, 0x0F42, 0x0FB7},
{ 0x0F4D, 0x0F4C, 0x0FB7},
{ 0x0F52, 0x0F51, 0x0FB7},
{ 0x0F57, 0x0F56, 0x0FB7},
{ 0x0F5C, 0x0F5B, 0x0FB7},
{ 0x0F73, 0x0F71, 0x0F72},
{ 0x0F75, 0x0F71, 0x0F74},
{ 0x0F81, 0x0F71, 0x0F80},
{ 0x0FB9, 0x0F90, 0x0FB5},
{ 0x0F93, 0x0F92, 0x0FB7},
{ 0x0F9D, 0x0F9C, 0x0FB7},
{ 0x0FA2, 0x0FA1, 0x0FB7},
{ 0x0FA7, 0x0FA6, 0x0FB7},
{ 0x0FAC, 0x0FAB, 0x0FB7},
{ 0x0F76, 0x0FB2, 0x0F80},
{ 0x0F78, 0x0FB3, 0x0F80},
{ 0x1026, 0x1025, 0x102E},
{ 0x1B06, 0x1B05, 0x1B35},
{ 0x1B08, 0x1B07, 0x1B35},
{ 0x1B0A, 0x1B09, 0x1B35},
{ 0x1B0C, 0x1B0B, 0x1B35},
{ 0x1B0E, 0x1B0D, 0x1B35},
{ 0x1B12, 0x1B11, 0x1B35},
{ 0x1B3B, 0x1B3A, 0x1B35},
{ 0x1B3D, 0x1B3C, 0x1B35},
{ 0x1B40, 0x1B3E, 0x1B35},
{ 0x1B41, 0x1B3F, 0x1B35},
{ 0x1B43, 0x1B42, 0x1B35},
{ 0x1E38, 0x1E36, 0x0304},
{ 0x1E39, 0x1E37, 0x0304},
{ 0x1E5C, 0x1E5A, 0x0304},
{ 0x1E5D, 0x1E5B, 0x0304},
{ 0x1E68, 0x1E62, 0x0307},
{ 0x1E69, 0x1E63, 0x0307},
{ 0x1EAC, 0x1EA0, 0x0302},
{ 0x1EB6, 0x1EA0, 0x0306},
{ 0x1EAD, 0x1EA1, 0x0302},
{ 0x1EB7, 0x1EA1, 0x0306},
{ 0x1EC6, 0x1EB8, 0x0302},
{ 0x1EC7, 0x1EB9, 0x0302},
{ 0x1ED8, 0x1ECC, 0x0302},
{ 0x1ED9, 0x1ECD, 0x0302},
{ 0x1F02, 0x1F00, 0x0300},
{ 0x1F04, 0x1F00, 0x0301},
{ 0x1F06, 0x1F00, 0x0342},
{ 0x1F80, 0x1F00, 0x0345},
{ 0x1F03, 0x1F01, 0x0300},
{ 0x1F05, 0x1F01, 0x0301},
{ 0x1F07, 0x1F01, 0x0342},
{ 0x1F81, 0x1F01, 0x0345},
{ 0x1F82, 0x1F02, 0x0345},
{ 0x1F83, 0x1F03, 0x0345},
{ 0x1F84, 0x1F04, 0x0345},
{ 0x1F85, 0x1F05, 0x0345},
{ 0x1F86, 0x1F06, 0x0345},
{ 0x1F87, 0x1F07, 0x0345},
{ 0x1F0A, 0x1F08, 0x0300},
{ 0x1F0C, 0x1F08, 0x0301},
{ 0x1F0E, 0x1F08, 0x0342},
{ 0x1F88, 0x1F08, 0x0345},
{ 0x1F0B, 0x1F09, 0x0300},
{ 0x1F0D, 0x1F09, 0x0301},
{ 0x1F0F, 0x1F09, 0x0342},
{ 0x1F89, 0x1F09, 0x0345},
{ 0x1F8A, 0x1F0A, 0x0345},
{ 0x1F8B, 0x1F0B, 0x0345},
{ 0x1F8C, 0x1F0C, 0x0345},
{ 0x1F8D, 0x1F0D, 0x0345},
{ 0x1F8E, 0x1F0E, 0x0345},
{ 0x1F8F, 0x1F0F, 0x0345},
{ 0x1F12, 0x1F10, 0x0300},
{ 0x1F14, 0x1F10, 0x0301},
{ 0x1F13, 0x1F11, 0x0300},
{ 0x1F15, 0x1F11, 0x0301},
{ 0x1F1A, 0x1F18, 0x0300},
{ 0x1F1C, 0x1F18, 0x0301},
{ 0x1F1B, 0x1F19, 0x0300},
{ 0x1F1D, 0x1F19, 0x0301},
{ 0x1F22, 0x1F20, 0x0300},
{ 0x1F24, 0x1F20, 0x0301},
{ 0x1F26, 0x1F20, 0x0342},
{ 0x1F90, 0x1F20, 0x0345},
{ 0x1F23, 0x1F21, 0x0300},
{ 0x1F25, 0x1F21, 0x0301},
{ 0x1F27, 0x1F21, 0x0342},
{ 0x1F91, 0x1F21, 0x0345},
{ 0x1F92, 0x1F22, 0x0345},
{ 0x1F93, 0x1F23, 0x0345},
{ 0x1F94, 0x1F24, 0x0345},
{ 0x1F95, 0x1F25, 0x0345},
{ 0x1F96, 0x1F26, 0x0345},
{ 0x1F97, 0x1F27, 0x0345},
{ 0x1F2A, 0x1F28, 0x0300},
{ 0x1F2C, 0x1F28, 0x0301},
{ 0x1F2E, 0x1F28, 0x0342},
{ 0x1F98, 0x1F28, 0x0345},
{ 0x1F2B, 0x1F29, 0x0300},
{ 0x1F2D, 0x1F29, 0x0301},
{ 0x1F2F, 0x1F29, 0x0342},
{ 0x1F99, 0x1F29, 0x0345},
{ 0x1F9A, 0x1F2A, 0x0345},
{ 0x1F9B, 0x1F2B, 0x0345},
{ 0x1F9C, 0x1F2C, 0x0345},
{ 0x1F9D, 0x1F2D, 0x0345},
{ 0x1F9E, 0x1F2E, 0x0345},
{ 0x1F9F, 0x1F2F, 0x0345},
{ 0x1F32, 0x1F30, 0x0300},
{ 0x1F34, 0x1F30, 0x0301},
{ 0x1F36, 0x1F30, 0x0342},
{ 0x1F33, 0x1F31, 0x0300},
{ 0x1F35, 0x1F31, 0x0301},
{ 0x1F37, 0x1F31, 0x0342},
{ 0x1F3A, 0x1F38, 0x0300},
{ 0x1F3C, 0x1F38, 0x0301},
{ 0x1F3E, 0x1F38, 0x0342},
{ 0x1F3B, 0x1F39, 0x0300},
{ 0x1F3D, 0x1F39, 0x0301},
{ 0x1F3F, 0x1F39, 0x0342},
{ 0x1F42, 0x1F40, 0x0300},
{ 0x1F44, 0x1F40, 0x0301},
{ 0x1F43, 0x1F41, 0x0300},
{ 0x1F45, 0x1F41, 0x0301},
{ 0x1F4A, 0x1F48, 0x0300},
{ 0x1F4C, 0x1F48, 0x0301},
{ 0x1F4B, 0x1F49, 0x0300},
{ 0x1F4D, 0x1F49, 0x0301},
{ 0x1F52, 0x1F50, 0x0300},
{ 0x1F54, 0x1F50, 0x0301},
{ 0x1F56, 0x1F50, 0x0342},
{ 0x1F53, 0x1F51, 0x0300},
{ 0x1F55, 0x1F51, 0x0301},
{ 0x1F57, 0x1F51, 0x0342},
{ 0x1F5B, 0x1F59, 0x0300},
{ 0x1F5D, 0x1F59, 0x0301},
{ 0x1F5F, 0x1F59, 0x0342},
{ 0x1F62, 0x1F60, 0x0300},
{ 0x1F64, 0x1F60, 0x0301},
{ 0x1F66, 0x1F60, 0x0342},
{ 0x1FA0, 0x1F60, 0x0345},
{ 0x1F63, 0x1F61, 0x0300},
{ 0x1F65, 0x1F61, 0x0301},
{ 0x1F67, 0x1F61, 0x0342},
{ 0x1FA1, 0x1F61, 0x0345},
{ 0x1FA2, 0x1F62, 0x0345},
{ 0x1FA3, 0x1F63, 0x0345},
{ 0x1FA4, 0x1F64, 0x0345},
{ 0x1FA5, 0x1F65, 0x0345},
{ 0x1FA6, 0x1F66, 0x0345},
{ 0x1FA7, 0x1F67, 0x0345},
{ 0x1F6A, 0x1F68, 0x0300},
{ 0x1F6C, 0x1F68, 0x0301},
{ 0x1F6E, 0x1F68, 0x0342},
{ 0x1FA8, 0x1F68, 0x0345},
{ 0x1F6B, 0x1F69, 0x0300},
{ 0x1F6D, 0x1F69, 0x0301},
{ 0x1F6F, 0x1F69, 0x0342},
{ 0x1FA9, 0x1F69, 0x0345},
{ 0x1FAA, 0x1F6A, 0x0345},
{ 0x1FAB, 0x1F6B, 0x0345},
{ 0x1FAC, 0x1F6C, 0x0345},
{ 0x1FAD, 0x1F6D, 0x0345},
{ 0x1FAE, 0x1F6E, 0x0345},
{ 0x1FAF, 0x1F6F, 0x0345},
{ 0x1FB2, 0x1F70, 0x0345},
{ 0x1FC2, 0x1F74, 0x0345},
{ 0x1FF2, 0x1F7C, 0x0345},
{ 0x1FB7, 0x1FB6, 0x0345},
{ 0x1FCD, 0x1FBF, 0x0300},
{ 0x1FCE, 0x1FBF, 0x0301},
{ 0x1FCF, 0x1FBF, 0x0342},
{ 0x1FC7, 0x1FC6, 0x0345},
{ 0x1FF7, 0x1FF6, 0x0345},
{ 0x1FDD, 0x1FFE, 0x0300},
{ 0x1FDE, 0x1FFE, 0x0301},
{ 0x1FDF, 0x1FFE, 0x0342},
{ 0x219A, 0x2190, 0x0338},
{ 0x219B, 0x2192, 0x0338},
{ 0x21AE, 0x2194, 0x0338},
{ 0x21CD, 0x21D0, 0x0338},
{ 0x21CF, 0x21D2, 0x0338},
{ 0x21CE, 0x21D4, 0x0338},
{ 0x2204, 0x2203, 0x0338},
{ 0x2209, 0x2208, 0x0338},
{ 0x220C, 0x220B, 0x0338},
{ 0x2224, 0x2223, 0x0338},
{ 0x2226, 0x2225, 0x0338},
{ 0x2241, 0x223C, 0x0338},
{ 0x2244, 0x2243, 0x0338},
{ 0x2247, 0x2245, 0x0338},
{ 0x2249, 0x2248, 0x0338},
{ 0x226D, 0x224D, 0x0338},
{ 0x2262, 0x2261, 0x0338},
{ 0x2270, 0x2264, 0x0338},
{ 0x2271, 0x2265, 0x0338},
{ 0x2274, 0x2272, 0x0338},
{ 0x2275, 0x2273, 0x0338},
{ 0x2278, 0x2276, 0x0338},
{ 0x2279, 0x2277, 0x0338},
{ 0x2280, 0x227A, 0x0338},
{ 0x2281, 0x227B, 0x0338},
{ 0x22E0, 0x227C, 0x0338},
{ 0x22E1, 0x227D, 0x0338},
{ 0x2284, 0x2282, 0x0338},
{ 0x2285, 0x2283, 0x0338},
{ 0x2288, 0x2286, 0x0338},
{ 0x2289, 0x2287, 0x0338},
{ 0x22E2, 0x2291, 0x0338},
{ 0x22E3, 0x2292, 0x0338},
{ 0x22AC, 0x22A2, 0x0338},
{ 0x22AD, 0x22A8, 0x0338},
{ 0x22AE, 0x22A9, 0x0338},
{ 0x22AF, 0x22AB, 0x0338},
{ 0x22EA, 0x22B2, 0x0338},
{ 0x22EB, 0x22B3, 0x0338},
{ 0x22EC, 0x22B4, 0x0338},
{ 0x22ED, 0x22B5, 0x0338},
{ 0x2ADC, 0x2ADD, 0x0338},
{ 0x3094, 0x3046, 0x3099},
{ 0x304C, 0x304B, 0x3099},
{ 0x304E, 0x304D, 0x3099},
{ 0x3050, 0x304F, 0x3099},
{ 0x3052, 0x3051, 0x3099},
{ 0x3054, 0x3053, 0x3099},
{ 0x3056, 0x3055, 0x3099},
{ 0x3058, 0x3057, 0x3099},
{ 0x305A, 0x3059, 0x3099},
{ 0x305C, 0x305B, 0x3099},
{ 0x305E, 0x305D, 0x3099},
{ 0x3060, 0x305F, 0x3099},
{ 0x3062, 0x3061, 0x3099},
{ 0x3065, 0x3064, 0x3099},
{ 0x3067, 0x3066, 0x3099},
{ 0x3069, 0x3068, 0x3099},
{ 0x3070, 0x306F, 0x3099},
{ 0x3071, 0x306F, 0x309A},
{ 0x3073, 0x3072, 0x3099},
{ 0x3074, 0x3072, 0x309A},
{ 0x3076, 0x3075, 0x3099},
{ 0x3077, 0x3075, 0x309A},
{ 0x3079, 0x3078, 0x3099},
{ 0x307A, 0x3078, 0x309A},
{ 0x307C, 0x307B, 0x3099},
{ 0x307D, 0x307B, 0x309A},
{ 0x309E, 0x309D, 0x3099},
{ 0x30F4, 0x30A6, 0x3099},
{ 0x30AC, 0x30AB, 0x3099},
{ 0x30AE, 0x30AD, 0x3099},
{ 0x30B0, 0x30AF, 0x3099},
{ 0x30B2, 0x30B1, 0x3099},
{ 0x30B4, 0x30B3, 0x3099},
{ 0x30B6, 0x30B5, 0x3099},
{ 0x30B8, 0x30B7, 0x3099},
{ 0x30BA, 0x30B9, 0x3099},
{ 0x30BC, 0x30BB, 0x3099},
{ 0x30BE, 0x30BD, 0x3099},
{ 0x30C0, 0x30BF, 0x3099},
{ 0x30C2, 0x30C1, 0x3099},
{ 0x30C5, 0x30C4, 0x3099},
{ 0x30C7, 0x30C6, 0x3099},
{ 0x30C9, 0x30C8, 0x3099},
{ 0x30D0, 0x30CF, 0x3099},
{ 0x30D1, 0x30CF, 0x309A},
{ 0x30D3, 0x30D2, 0x3099},
{ 0x30D4, 0x30D2, 0x309A},
{ 0x30D6, 0x30D5, 0x3099},
{ 0x30D7, 0x30D5, 0x309A},
{ 0x30D9, 0x30D8, 0x3099},
{ 0x30DA, 0x30D8, 0x309A},
{ 0x30DC, 0x30DB, 0x3099},
{ 0x30DD, 0x30DB, 0x309A},
{ 0x30F7, 0x30EF, 0x3099},
{ 0x30F8, 0x30F0, 0x3099},
{ 0x30F9, 0x30F1, 0x3099},
{ 0x30FA, 0x30F2, 0x3099},
{ 0x30FE, 0x30FD, 0x3099},
{ 0xFB2C, 0xFB49, 0x05C1},
{ 0xFB2D, 0xFB49, 0x05C2},
};
private static final int UNICODE_SHIFT = 21;
public static char precompose(char base, char comb) {
int min = 0;
int max = precompositions.length - 1;
int mid;
long sought = base << UNICODE_SHIFT | comb;
long that;
while (max >= min) {
mid = (min + max) / 2;
that = precompositions[mid][1] << UNICODE_SHIFT | precompositions[mid][2];
if (that < sought)
min = mid + 1;
else if (that > sought)
max = mid - 1;
else
return precompositions[mid][0];
}
// No match; return character without combiner
return base;
}
}
| Java |
/*
* This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
*
* (c) Matthias L. Jugel, Marcus Mei�ner 1996-2005. All Rights Reserved.
*
* Please visit http://javatelnet.org/ for updates and contact.
*
* --LICENSE NOTICE--
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* --LICENSE NOTICE--
*
*/
package de.mud.terminal;
import java.util.Arrays;
/**
* Implementation of a Video Display Unit (VDU) buffer. This class contains
* all methods to manipulate the buffer that stores characters and their
* attributes as well as the regions displayed.
*
* @author Matthias L. Jugel, Marcus Meißner
* @version $Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $
*/
public class VDUBuffer {
/** The current version id tag */
public final static String ID = "$Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $";
/** Enable debug messages. */
public final static int debug = 0;
public int height, width; /* rows and columns */
public boolean[] update; /* contains the lines that need update */
public char[][] charArray; /* contains the characters */
public int[][] charAttributes; /* contains character attrs */
public int bufSize;
public int maxBufSize; /* buffer sizes */
public int screenBase; /* the actual screen start */
public int windowBase; /* where the start displaying */
public int scrollMarker; /* marks the last line inserted */
private int topMargin; /* top scroll margin */
private int bottomMargin; /* bottom scroll margin */
// cursor variables
protected boolean showcursor = true;
protected int cursorX, cursorY;
/** Scroll up when inserting a line. */
public final static boolean SCROLL_UP = false;
/** Scroll down when inserting a line. */
public final static boolean SCROLL_DOWN = true;
/* Attributes bit-field usage:
*
* 8421 8421 8421 8421 8421 8421 8421 8421
* |||| |||| |||| |||| |||| |||| |||| |||`- Bold
* |||| |||| |||| |||| |||| |||| |||| ||`-- Underline
* |||| |||| |||| |||| |||| |||| |||| |`--- Invert
* |||| |||| |||| |||| |||| |||| |||| `---- Low
* |||| |||| |||| |||| |||| |||| |||`------ Invisible
* |||| |||| |||| |||| ||`+-++++-+++------- Foreground Color
* |||| |||| |`++-++++-++------------------ Background Color
* |||| |||| `----------------------------- Fullwidth character
* `+++-++++------------------------------- Reserved for future use
*/
/** Make character normal. */
public final static int NORMAL = 0x00;
/** Make character bold. */
public final static int BOLD = 0x01;
/** Underline character. */
public final static int UNDERLINE = 0x02;
/** Invert character. */
public final static int INVERT = 0x04;
/** Lower intensity character. */
public final static int LOW = 0x08;
/** Invisible character. */
public final static int INVISIBLE = 0x10;
/** Unicode full-width character (CJK, et al.) */
public final static int FULLWIDTH = 0x8000000;
/** how much to left shift the foreground color */
public final static int COLOR_FG_SHIFT = 5;
/** how much to left shift the background color */
public final static int COLOR_BG_SHIFT = 14;
/** color mask */
public final static int COLOR = 0x7fffe0; /* 0000 0000 0111 1111 1111 1111 1110 0000 */
/** foreground color mask */
public final static int COLOR_FG = 0x3fe0; /* 0000 0000 0000 0000 0011 1111 1110 0000 */
/** background color mask */
public final static int COLOR_BG = 0x7fc000; /* 0000 0000 0111 1111 1100 0000 0000 0000 */
/**
* Create a new video display buffer with the passed width and height in
* characters.
* @param width the length of the character lines
* @param height the amount of lines on the screen
*/
public VDUBuffer(int width, int height) {
// set the display screen size
setScreenSize(width, height, false);
}
/**
* Create a standard video display buffer with 80 columns and 24 lines.
*/
public VDUBuffer() {
this(80, 24);
}
/**
* Put a character on the screen with normal font and outline.
* The character previously on that position will be overwritten.
* You need to call redraw() to update the screen.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @param ch the character to show on the screen
* @see #insertChar
* @see #deleteChar
* @see #redraw
*/
public void putChar(int c, int l, char ch) {
putChar(c, l, ch, NORMAL);
}
/**
* Put a character on the screen with specific font and outline.
* The character previously on that position will be overwritten.
* You need to call redraw() to update the screen.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @param ch the character to show on the screen
* @param attributes the character attributes
* @see #BOLD
* @see #UNDERLINE
* @see #INVERT
* @see #INVISIBLE
* @see #NORMAL
* @see #LOW
* @see #insertChar
* @see #deleteChar
* @see #redraw
*/
public void putChar(int c, int l, char ch, int attributes) {
charArray[screenBase + l][c] = ch;
charAttributes[screenBase + l][c] = attributes;
if (l < height)
update[l + 1] = true;
}
/**
* Get the character at the specified position.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @see #putChar
*/
public char getChar(int c, int l) {
return charArray[screenBase + l][c];
}
/**
* Get the attributes for the specified position.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @see #putChar
*/
public int getAttributes(int c, int l) {
return charAttributes[screenBase + l][c];
}
/**
* Insert a character at a specific position on the screen.
* All character right to from this position will be moved one to the right.
* You need to call redraw() to update the screen.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @param ch the character to insert
* @param attributes the character attributes
* @see #BOLD
* @see #UNDERLINE
* @see #INVERT
* @see #INVISIBLE
* @see #NORMAL
* @see #LOW
* @see #putChar
* @see #deleteChar
* @see #redraw
*/
public void insertChar(int c, int l, char ch, int attributes) {
System.arraycopy(charArray[screenBase + l], c,
charArray[screenBase + l], c + 1, width - c - 1);
System.arraycopy(charAttributes[screenBase + l], c,
charAttributes[screenBase + l], c + 1, width - c - 1);
putChar(c, l, ch, attributes);
}
/**
* Delete a character at a given position on the screen.
* All characters right to the position will be moved one to the left.
* You need to call redraw() to update the screen.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @see #putChar
* @see #insertChar
* @see #redraw
*/
public void deleteChar(int c, int l) {
if (c < width - 1) {
System.arraycopy(charArray[screenBase + l], c + 1,
charArray[screenBase + l], c, width - c - 1);
System.arraycopy(charAttributes[screenBase + l], c + 1,
charAttributes[screenBase + l], c, width - c - 1);
}
putChar(width - 1, l, (char) 0);
}
/**
* Put a String at a specific position. Any characters previously on that
* position will be overwritten. You need to call redraw() for screen update.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @param s the string to be shown on the screen
* @see #BOLD
* @see #UNDERLINE
* @see #INVERT
* @see #INVISIBLE
* @see #NORMAL
* @see #LOW
* @see #putChar
* @see #insertLine
* @see #deleteLine
* @see #redraw
*/
public void putString(int c, int l, String s) {
putString(c, l, s, NORMAL);
}
/**
* Put a String at a specific position giving all characters the same
* attributes. Any characters previously on that position will be
* overwritten. You need to call redraw() to update the screen.
* @param c x-coordinate (column)
* @param l y-coordinate (line)
* @param s the string to be shown on the screen
* @param attributes character attributes
* @see #BOLD
* @see #UNDERLINE
* @see #INVERT
* @see #INVISIBLE
* @see #NORMAL
* @see #LOW
* @see #putChar
* @see #insertLine
* @see #deleteLine
* @see #redraw
*/
public void putString(int c, int l, String s, int attributes) {
for (int i = 0; i < s.length() && c + i < width; i++)
putChar(c + i, l, s.charAt(i), attributes);
}
/**
* Insert a blank line at a specific position.
* The current line and all previous lines are scrolled one line up. The
* top line is lost. You need to call redraw() to update the screen.
* @param l the y-coordinate to insert the line
* @see #deleteLine
* @see #redraw
*/
public void insertLine(int l) {
insertLine(l, 1, SCROLL_UP);
}
/**
* Insert blank lines at a specific position.
* You need to call redraw() to update the screen
* @param l the y-coordinate to insert the line
* @param n amount of lines to be inserted
* @see #deleteLine
* @see #redraw
*/
public void insertLine(int l, int n) {
insertLine(l, n, SCROLL_UP);
}
/**
* Insert a blank line at a specific position. Scroll text according to
* the argument.
* You need to call redraw() to update the screen
* @param l the y-coordinate to insert the line
* @param scrollDown scroll down
* @see #deleteLine
* @see #SCROLL_UP
* @see #SCROLL_DOWN
* @see #redraw
*/
public void insertLine(int l, boolean scrollDown) {
insertLine(l, 1, scrollDown);
}
/**
* Insert blank lines at a specific position.
* The current line and all previous lines are scrolled one line up. The
* top line is lost. You need to call redraw() to update the screen.
* @param l the y-coordinate to insert the line
* @param n number of lines to be inserted
* @param scrollDown scroll down
* @see #deleteLine
* @see #SCROLL_UP
* @see #SCROLL_DOWN
* @see #redraw
*/
public synchronized void insertLine(int l, int n, boolean scrollDown) {
char cbuf[][] = null;
int abuf[][] = null;
int offset = 0;
int oldBase = screenBase;
int newScreenBase = screenBase;
int newWindowBase = windowBase;
int newBufSize = bufSize;
if (l > bottomMargin) /* We do not scroll below bottom margin (below the scrolling region). */
return;
int top = (l < topMargin ?
0 : (l > bottomMargin ?
(bottomMargin + 1 < height ?
bottomMargin + 1 : height - 1) : topMargin));
int bottom = (l > bottomMargin ?
height - 1 : (l < topMargin ?
(topMargin > 0 ?
topMargin - 1 : 0) : bottomMargin));
// System.out.println("l is "+l+", top is "+top+", bottom is "+bottom+", bottomargin is "+bottomMargin+", topMargin is "+topMargin);
if (scrollDown) {
if (n > (bottom - top)) n = (bottom - top);
int size = bottom - l - (n - 1);
if(size < 0) size = 0;
cbuf = new char[size][];
abuf = new int[size][];
System.arraycopy(charArray, oldBase + l, cbuf, 0, bottom - l - (n - 1));
System.arraycopy(charAttributes, oldBase + l,
abuf, 0, bottom - l - (n - 1));
System.arraycopy(cbuf, 0, charArray, oldBase + l + n,
bottom - l - (n - 1));
System.arraycopy(abuf, 0, charAttributes, oldBase + l + n,
bottom - l - (n - 1));
cbuf = charArray;
abuf = charAttributes;
} else {
try {
if (n > (bottom - top) + 1) n = (bottom - top) + 1;
if (bufSize < maxBufSize) {
if (bufSize + n > maxBufSize) {
offset = n - (maxBufSize - bufSize);
scrollMarker += offset;
newBufSize = maxBufSize;
newScreenBase = maxBufSize - height - 1;
newWindowBase = screenBase;
} else {
scrollMarker += n;
newScreenBase += n;
newWindowBase += n;
newBufSize += n;
}
cbuf = new char[newBufSize][];
abuf = new int[newBufSize][];
} else {
offset = n;
cbuf = charArray;
abuf = charAttributes;
}
// copy anything from the top of the buffer (+offset) to the new top
// up to the screenBase.
if (oldBase > 0) {
System.arraycopy(charArray, offset,
cbuf, 0,
oldBase - offset);
System.arraycopy(charAttributes, offset,
abuf, 0,
oldBase - offset);
}
// copy anything from the top of the screen (screenBase) up to the
// topMargin to the new screen
if (top > 0) {
System.arraycopy(charArray, oldBase,
cbuf, newScreenBase,
top);
System.arraycopy(charAttributes, oldBase,
abuf, newScreenBase,
top);
}
// copy anything from the topMargin up to the amount of lines inserted
// to the gap left over between scrollback buffer and screenBase
if (oldBase >= 0) {
System.arraycopy(charArray, oldBase + top,
cbuf, oldBase - offset,
n);
System.arraycopy(charAttributes, oldBase + top,
abuf, oldBase - offset,
n);
}
// copy anything from topMargin + n up to the line linserted to the
// topMargin
System.arraycopy(charArray, oldBase + top + n,
cbuf, newScreenBase + top,
l - top - (n - 1));
System.arraycopy(charAttributes, oldBase + top + n,
abuf, newScreenBase + top,
l - top - (n - 1));
//
// copy the all lines next to the inserted to the new buffer
if (l < height - 1) {
System.arraycopy(charArray, oldBase + l + 1,
cbuf, newScreenBase + l + 1,
(height - 1) - l);
System.arraycopy(charAttributes, oldBase + l + 1,
abuf, newScreenBase + l + 1,
(height - 1) - l);
}
} catch (ArrayIndexOutOfBoundsException e) {
// this should not happen anymore, but I will leave the code
// here in case something happens anyway. That code above is
// so complex I always have a hard time understanding what
// I did, even though there are comments
System.err.println("*** Error while scrolling up:");
System.err.println("--- BEGIN STACK TRACE ---");
e.printStackTrace();
System.err.println("--- END STACK TRACE ---");
System.err.println("bufSize=" + bufSize + ", maxBufSize=" + maxBufSize);
System.err.println("top=" + top + ", bottom=" + bottom);
System.err.println("n=" + n + ", l=" + l);
System.err.println("screenBase=" + screenBase + ", windowBase=" + windowBase);
System.err.println("newScreenBase=" + newScreenBase + ", newWindowBase=" + newWindowBase);
System.err.println("oldBase=" + oldBase);
System.err.println("size.width=" + width + ", size.height=" + height);
System.err.println("abuf.length=" + abuf.length + ", cbuf.length=" + cbuf.length);
System.err.println("*** done dumping debug information");
}
}
// this is a little helper to mark the scrolling
scrollMarker -= n;
for (int i = 0; i < n; i++) {
cbuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new char[width];
Arrays.fill(cbuf[(newScreenBase + l) + (scrollDown ? i : -i)], ' ');
abuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new int[width];
}
charArray = cbuf;
charAttributes = abuf;
screenBase = newScreenBase;
windowBase = newWindowBase;
bufSize = newBufSize;
if (scrollDown)
markLine(l, bottom - l + 1);
else
markLine(top, l - top + 1);
display.updateScrollBar();
}
/**
* Delete a line at a specific position. Subsequent lines will be scrolled
* up to fill the space and a blank line is inserted at the end of the
* screen.
* @param l the y-coordinate to insert the line
* @see #deleteLine
*/
public void deleteLine(int l) {
int bottom = (l > bottomMargin ? height - 1:
(l < topMargin?topMargin:bottomMargin + 1));
int numRows = bottom - l - 1;
char[] discardedChars = charArray[screenBase + l];
int[] discardedAttributes = charAttributes[screenBase + l];
if (numRows > 0) {
System.arraycopy(charArray, screenBase + l + 1,
charArray, screenBase + l, numRows);
System.arraycopy(charAttributes, screenBase + l + 1,
charAttributes, screenBase + l, numRows);
}
int newBottomRow = screenBase + bottom - 1;
charArray[newBottomRow] = discardedChars;
charAttributes[newBottomRow] = discardedAttributes;
Arrays.fill(charArray[newBottomRow], ' ');
Arrays.fill(charAttributes[newBottomRow], 0);
markLine(l, bottom - l);
}
/**
* Delete a rectangular portion of the screen.
* You need to call redraw() to update the screen.
* @param c x-coordinate (column)
* @param l y-coordinate (row)
* @param w with of the area in characters
* @param h height of the area in characters
* @param curAttr attribute to fill
* @see #deleteChar
* @see #deleteLine
* @see #redraw
*/
public void deleteArea(int c, int l, int w, int h, int curAttr) {
int endColumn = c + w;
int targetRow = screenBase + l;
for (int i = 0; i < h && l + i < height; i++) {
Arrays.fill(charAttributes[targetRow], c, endColumn, curAttr);
Arrays.fill(charArray[targetRow], c, endColumn, ' ');
targetRow++;
}
markLine(l, h);
}
/**
* Delete a rectangular portion of the screen.
* You need to call redraw() to update the screen.
* @param c x-coordinate (column)
* @param l y-coordinate (row)
* @param w with of the area in characters
* @param h height of the area in characters
* @see #deleteChar
* @see #deleteLine
* @see #redraw
*/
public void deleteArea(int c, int l, int w, int h) {
deleteArea(c, l, w, h, 0);
}
/**
* Sets whether the cursor is visible or not.
* @param doshow
*/
public void showCursor(boolean doshow) {
showcursor = doshow;
}
/**
* Check whether the cursor is currently visible.
* @return visibility
*/
public boolean isCursorVisible() {
return showcursor;
}
/**
* Puts the cursor at the specified position.
* @param c column
* @param l line
*/
public void setCursorPosition(int c, int l) {
cursorX = c;
cursorY = l;
}
/**
* Get the current column of the cursor position.
*/
public int getCursorColumn() {
return cursorX;
}
/**
* Get the current line of the cursor position.
*/
public int getCursorRow() {
return cursorY;
}
/**
* Set the current window base. This allows to view the scrollback buffer.
* @param line the line where the screen window starts
* @see #setBufferSize
* @see #getBufferSize
*/
public void setWindowBase(int line) {
if (line > screenBase)
line = screenBase;
else if (line < 0) line = 0;
windowBase = line;
update[0] = true;
redraw();
}
/**
* Get the current window base.
* @see #setWindowBase
*/
public int getWindowBase() {
return windowBase;
}
/**
* Set the scroll margins simultaneously. If they're out of bounds, trim them.
* @param l1 line that is the top
* @param l2 line that is the bottom
*/
public void setMargins(int l1, int l2) {
if (l1 > l2)
return;
if (l1 < 0)
l1 = 0;
if (l2 >= height)
l2 = height - 1;
topMargin = l1;
bottomMargin = l2;
}
/**
* Set the top scroll margin for the screen. If the current bottom margin
* is smaller it will become the top margin and the line will become the
* bottom margin.
* @param l line that is the margin
*/
public void setTopMargin(int l) {
if (l > bottomMargin) {
topMargin = bottomMargin;
bottomMargin = l;
} else
topMargin = l;
if (topMargin < 0) topMargin = 0;
if (bottomMargin >= height) bottomMargin = height - 1;
}
/**
* Get the top scroll margin.
*/
public int getTopMargin() {
return topMargin;
}
/**
* Set the bottom scroll margin for the screen. If the current top margin
* is bigger it will become the bottom margin and the line will become the
* top margin.
* @param l line that is the margin
*/
public void setBottomMargin(int l) {
if (l < topMargin) {
bottomMargin = topMargin;
topMargin = l;
} else
bottomMargin = l;
if (topMargin < 0) topMargin = 0;
if (bottomMargin >= height) bottomMargin = height - 1;
}
/**
* Get the bottom scroll margin.
*/
public int getBottomMargin() {
return bottomMargin;
}
/**
* Set scrollback buffer size.
* @param amount new size of the buffer
*/
public void setBufferSize(int amount) {
if (amount < height) amount = height;
if (amount < maxBufSize) {
char cbuf[][] = new char[amount][width];
int abuf[][] = new int[amount][width];
int copyStart = bufSize - amount < 0 ? 0 : bufSize - amount;
int copyCount = bufSize - amount < 0 ? bufSize : amount;
if (charArray != null)
System.arraycopy(charArray, copyStart, cbuf, 0, copyCount);
if (charAttributes != null)
System.arraycopy(charAttributes, copyStart, abuf, 0, copyCount);
charArray = cbuf;
charAttributes = abuf;
bufSize = copyCount;
screenBase = bufSize - height;
windowBase = screenBase;
}
maxBufSize = amount;
update[0] = true;
redraw();
}
/**
* Retrieve current scrollback buffer size.
* @see #setBufferSize
*/
public int getBufferSize() {
return bufSize;
}
/**
* Retrieve maximum buffer Size.
* @see #getBufferSize
*/
public int getMaxBufferSize() {
return maxBufSize;
}
/**
* Change the size of the screen. This will include adjustment of the
* scrollback buffer.
* @param w of the screen
* @param h of the screen
*/
public void setScreenSize(int w, int h, boolean broadcast) {
char cbuf[][];
int abuf[][];
int maxSize = bufSize;
if (w < 1 || h < 1) return;
if (debug > 0)
System.err.println("VDU: screen size [" + w + "," + h + "]");
if (h > maxBufSize)
maxBufSize = h;
if (h > bufSize) {
bufSize = h;
screenBase = 0;
windowBase = 0;
}
if (windowBase + h >= bufSize)
windowBase = bufSize - h;
if (screenBase + h >= bufSize)
screenBase = bufSize - h;
cbuf = new char[bufSize][w];
abuf = new int[bufSize][w];
for (int i = 0; i < bufSize; i++) {
Arrays.fill(cbuf[i], ' ');
}
if (bufSize < maxSize)
maxSize = bufSize;
int rowLength;
if (charArray != null && charAttributes != null) {
for (int i = 0; i < maxSize && charArray[i] != null; i++) {
rowLength = charArray[i].length;
System.arraycopy(charArray[i], 0, cbuf[i], 0,
w < rowLength ? w : rowLength);
System.arraycopy(charAttributes[i], 0, abuf[i], 0,
w < rowLength ? w : rowLength);
}
}
int C = getCursorColumn();
if (C < 0)
C = 0;
else if (C >= width)
C = width - 1;
int R = getCursorRow();
if (R < 0)
R = 0;
else if (R >= height)
R = height - 1;
setCursorPosition(C, R);
charArray = cbuf;
charAttributes = abuf;
width = w;
height = h;
topMargin = 0;
bottomMargin = h - 1;
update = new boolean[h + 1];
update[0] = true;
/* FIXME: ???
if(resizeStrategy == RESIZE_FONT)
setBounds(getBounds());
*/
}
/**
* Get amount of rows on the screen.
*/
public int getRows() {
return height;
}
/**
* Get amount of columns on the screen.
*/
public int getColumns() {
return width;
}
/**
* Mark lines to be updated with redraw().
* @param l starting line
* @param n amount of lines to be updated
* @see #redraw
*/
public void markLine(int l, int n) {
for (int i = 0; (i < n) && (l + i < height); i++)
update[l + i + 1] = true;
}
// private static int checkBounds(int value, int lower, int upper) {
// if (value < lower)
// return lower;
// else if (value > upper)
// return upper;
// else
// return value;
// }
/** a generic display that should redraw on demand */
protected VDUDisplay display;
public void setDisplay(VDUDisplay display) {
this.display = display;
}
/**
* Trigger a redraw on the display.
*/
protected void redraw() {
if (display != null)
display.redraw();
}
}
| Java |
/*
* This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
*
* (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
*
* Please visit http://javatelnet.org/ for updates and contact.
*
* --LICENSE NOTICE--
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* --LICENSE NOTICE--
*
*/
package de.mud.terminal;
import java.util.Properties;
/**
* An interface for a terminal that accepts input from keyboard and mouse.
*
* @author Matthias L. Jugel, Marcus Meißner
* @version $Id: VDUInput.java 499 2005-09-29 08:24:54Z leo $
*/
public interface VDUInput {
public final static int KEY_CONTROL = 0x01;
public final static int KEY_SHIFT = 0x02;
public final static int KEY_ALT = 0x04;
public final static int KEY_ACTION = 0x08;
/**
* Direct access to writing data ...
* @param b
*/
void write(byte b[]);
/**
* Terminal is mouse-aware and requires (x,y) coordinates of
* on the terminal (character coordinates) and the button clicked.
* @param x
* @param y
* @param modifiers
*/
void mousePressed(int x, int y, int modifiers);
/**
* Terminal is mouse-aware and requires the coordinates and button
* of the release.
* @param x
* @param y
* @param modifiers
*/
void mouseReleased(int x, int y, int modifiers);
/**
* Override the standard key codes used by the terminal emulation.
* @param codes a properties object containing key code definitions
*/
void setKeyCodes(Properties codes);
/**
* main keytyping event handler...
* @param keyCode the key code
* @param keyChar the character represented by the key
* @param modifiers shift/alt/control modifiers
*/
void keyPressed(int keyCode, char keyChar, int modifiers);
/**
* Handle key Typed events for the terminal, this will get
* all normal key types, but no shift/alt/control/numlock.
* @param keyCode the key code
* @param keyChar the character represented by the key
* @param modifiers shift/alt/control modifiers
*/
void keyTyped(int keyCode, char keyChar, int modifiers);
}
| Java |
/*
* This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
*
* (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
*
* Please visit http://javatelnet.org/ for updates and contact.
*
* --LICENSE NOTICE--
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* --LICENSE NOTICE--
*
*/
package de.mud.telnet;
import java.io.IOException;
/**
* This is a telnet protocol handler. The handler needs implementations
* for several methods to handle the telnet options and to be able to
* read and write the buffer.
* <P>
* <B>Maintainer:</B> Marcus Meissner
*
* @version $Id: TelnetProtocolHandler.java 503 2005-10-24 07:34:13Z marcus $
* @author Matthias L. Jugel, Marcus Meissner
*/
public abstract class TelnetProtocolHandler {
/** contains the current revision id */
public final static String ID = "$Id: TelnetProtocolHandler.java 503 2005-10-24 07:34:13Z marcus $";
/** debug level */
private final static int debug = 0;
/** temporary buffer for data-telnetstuff-data transformation */
private byte[] tempbuf = new byte[0];
/** the data sent on pressing <RETURN> \n */
private byte[] crlf = new byte[2];
/** the data sent on pressing <LineFeed> \r */
private byte[] cr = new byte[2];
/**
* Create a new telnet protocol handler.
*/
public TelnetProtocolHandler() {
reset();
crlf[0] = 13; crlf[1] = 10;
cr[0] = 13; cr[1] = 0;
}
/**
* Get the current terminal type for TTYPE telnet option.
* @return the string id of the terminal
*/
protected abstract String getTerminalType();
/**
* Get the current window size of the terminal for the
* NAWS telnet option.
* @return the size of the terminal as Dimension
*/
protected abstract int[] getWindowSize();
/**
* Set the local echo option of telnet.
* @param echo true for local echo, false for no local echo
*/
protected abstract void setLocalEcho(boolean echo);
/**
* Generate an EOR (end of record) request. For use by prompt displaying.
*/
protected abstract void notifyEndOfRecord();
/**
* Send data to the remote host.
* @param b array of bytes to send
*/
protected abstract void write(byte[] b) throws IOException;
/**
* Read the charset name from terminal.
*/
protected abstract String getCharsetName();
/**
* Send one byte to the remote host.
* @param b the byte to be sent
* @see #write(byte[] b)
*/
private static byte[] one = new byte[1];
private void write(byte b) throws IOException {
one[0] = b;
write(one);
}
/**
* Reset the protocol handler. This may be necessary after the
* connection was closed or some other problem occured.
*/
public void reset() {
neg_state = 0;
receivedDX = new byte[256];
sentDX = new byte[256];
receivedWX = new byte[256];
sentWX = new byte[256];
}
// ===================================================================
// the actual negotiation handling for the telnet protocol follows:
// ===================================================================
/** state variable for telnet negotiation reader */
private byte neg_state = 0;
/** constants for the negotiation state */
private final static byte STATE_DATA = 0;
private final static byte STATE_IAC = 1;
private final static byte STATE_IACSB = 2;
private final static byte STATE_IACWILL = 3;
private final static byte STATE_IACDO = 4;
private final static byte STATE_IACWONT = 5;
private final static byte STATE_IACDONT = 6;
private final static byte STATE_IACSBIAC = 7;
private final static byte STATE_IACSBDATA = 8;
private final static byte STATE_IACSBDATAIAC = 9;
/** What IAC SB <xx> we are handling right now */
private byte current_sb;
/** current SB negotiation buffer */
private byte[] sbbuf;
/** IAC - init sequence for telnet negotiation. */
private final static byte IAC = (byte)255;
/** [IAC] End Of Record */
private final static byte EOR = (byte)239;
/** [IAC] WILL */
private final static byte WILL = (byte)251;
/** [IAC] WONT */
private final static byte WONT = (byte)252;
/** [IAC] DO */
private final static byte DO = (byte)253;
/** [IAC] DONT */
private final static byte DONT = (byte)254;
/** [IAC] Sub Begin */
private final static byte SB = (byte)250;
/** [IAC] Sub End */
private final static byte SE = (byte)240;
/** Telnet option: binary mode */
private final static byte TELOPT_BINARY= (byte)0; /* binary mode */
/** Telnet option: echo text */
private final static byte TELOPT_ECHO = (byte)1; /* echo on/off */
/** Telnet option: sga */
private final static byte TELOPT_SGA = (byte)3; /* supress go ahead */
/** Telnet option: End Of Record */
private final static byte TELOPT_EOR = (byte)25; /* end of record */
/** Telnet option: Negotiate About Window Size */
private final static byte TELOPT_NAWS = (byte)31; /* NA-WindowSize*/
/** Telnet option: Terminal Type */
private final static byte TELOPT_TTYPE = (byte)24; /* terminal type */
/** Telnet option: CHARSET */
private final static byte TELOPT_CHARSET= (byte)42; /* charset */
private final static byte[] IACWILL = { IAC, WILL };
private final static byte[] IACWONT = { IAC, WONT };
private final static byte[] IACDO = { IAC, DO };
private final static byte[] IACDONT = { IAC, DONT };
private final static byte[] IACSB = { IAC, SB };
private final static byte[] IACSE = { IAC, SE };
private final static byte CHARSET_ACCEPTED = (byte)2;
private final static byte CHARSET_REJECTED = (byte)3;
/** Telnet option qualifier 'IS' */
private final static byte TELQUAL_IS = (byte)0;
/** Telnet option qualifier 'SEND' */
private final static byte TELQUAL_SEND = (byte)1;
/** What IAC DO(NT) request do we have received already ? */
private byte[] receivedDX;
/** What IAC WILL/WONT request do we have received already ? */
private byte[] receivedWX;
/** What IAC DO/DONT request do we have sent already ? */
private byte[] sentDX;
/** What IAC WILL/WONT request do we have sent already ? */
private byte[] sentWX;
/**
* Send a Telnet Escape character (IAC <code>)
*/
public void sendTelnetControl(byte code)
throws IOException {
byte[] b = new byte[2];
b[0] = IAC;
b[1] = code;
write(b);
}
/**
* Send the new Window Size (via NAWS)
*/
public void setWindowSize(int columns,int rows)
throws IOException {
if(debug > 2) System.err.println("sending NAWS");
if (receivedDX[TELOPT_NAWS] != DO) {
System.err.println("not allowed to send NAWS? (DONT NAWS)");
return;
}
write(IAC);write(SB);write(TELOPT_NAWS);
write((byte) (columns >> 8));
write((byte) (columns & 0xff));
write((byte) (rows >> 8));
write((byte) (rows & 0xff));
write(IAC);write(SE);
}
/**
* Handle an incoming IAC SB <type> <bytes> IAC SE
* @param type type of SB
* @param sbata byte array as <bytes>
*/
private void handle_sb(byte type, byte[] sbdata)
throws IOException {
if(debug > 1)
System.err.println("TelnetIO.handle_sb("+type+")");
switch (type) {
case TELOPT_TTYPE:
if (sbdata.length>0 && sbdata[0]==TELQUAL_SEND) {
write(IACSB);write(TELOPT_TTYPE);write(TELQUAL_IS);
/* FIXME: need more logic here if we use
* more than one terminal type
*/
String ttype = getTerminalType();
if(ttype == null) ttype = "dumb";
write(ttype.getBytes());
write(IACSE);
}
break;
case TELOPT_CHARSET:
System.out.println("Got SB CHARSET");
String charsetStr = new String(sbdata, "US-ASCII");
if (charsetStr.startsWith("TTABLE ")) {
charsetStr = charsetStr.substring(7);
}
String[] charsets = charsetStr.split(charsetStr.substring(0,0));
String myCharset = getCharsetName();
for (String charset : charsets) {
if (charset.equals(myCharset)) {
write(IACSB);write(TELOPT_CHARSET);write(CHARSET_ACCEPTED);
write(charset.getBytes());
write(IACSE);
System.out.println("Sent our charset!");
return;
}
}
write(IACSB);write(TELOPT_CHARSET);write(CHARSET_REJECTED);
write(IACSE);
break;
}
}
/**
* Do not send any notifications at startup. We do not know,
* whether the remote client understands telnet protocol handling,
* so we are silent.
* (This used to send IAC WILL SGA, but this is false for a compliant
* client.)
*/
public void startup() throws IOException {
}
/**
* Transpose special telnet codes like 0xff or newlines to values
* that are compliant to the protocol. This method will also send
* the buffer immediately after transposing the data.
* @param buf the data buffer to be sent
*/
public void transpose(byte[] buf) throws IOException {
int i;
byte[] nbuf,xbuf;
int nbufptr=0;
nbuf = new byte[buf.length*2]; // FIXME: buffer overflows possible
for (i = 0; i < buf.length ; i++) {
switch (buf[i]) {
// Escape IAC twice in stream ... to be telnet protocol compliant
// this is there in binary and non-binary mode.
case IAC:
nbuf[nbufptr++]=IAC;
nbuf[nbufptr++]=IAC;
break;
// We need to heed RFC 854. LF (\n) is 10, CR (\r) is 13
// we assume that the Terminal sends \n for lf+cr and \r for just cr
// linefeed+carriage return is CR LF */
case 10: // \n
if (receivedDX[TELOPT_BINARY + 128 ] != DO) {
while (nbuf.length - nbufptr < crlf.length) {
xbuf = new byte[nbuf.length*2];
System.arraycopy(nbuf,0,xbuf,0,nbufptr);
nbuf = xbuf;
}
for (int j=0;j<crlf.length;j++)
nbuf[nbufptr++]=crlf[j];
break;
} else {
// copy verbatim in binary mode.
nbuf[nbufptr++]=buf[i];
}
break;
// carriage return is CR NUL */
case 13: // \r
if (receivedDX[TELOPT_BINARY + 128 ] != DO) {
while (nbuf.length - nbufptr < cr.length) {
xbuf = new byte[nbuf.length*2];
System.arraycopy(nbuf,0,xbuf,0,nbufptr);
nbuf = xbuf;
}
for (int j=0;j<cr.length;j++)
nbuf[nbufptr++]=cr[j];
} else {
// copy verbatim in binary mode.
nbuf[nbufptr++]=buf[i];
}
break;
// all other characters are just copied
default:
nbuf[nbufptr++]=buf[i];
break;
}
}
xbuf = new byte[nbufptr];
System.arraycopy(nbuf,0,xbuf,0,nbufptr);
write(xbuf);
}
public void setCRLF(String xcrlf) { crlf = xcrlf.getBytes(); }
public void setCR(String xcr) { cr = xcr.getBytes(); }
/**
* Handle telnet protocol negotiation. The buffer will be parsed
* and necessary actions are taken according to the telnet protocol.
* See <A HREF="RFC-Telnet-URL">RFC-Telnet</A>
* @param nbuf the byte buffer put out after negotiation
* @return number of bytes processed, 0 for none, and -1 for end of buffer.
*/
public int negotiate(byte nbuf[], int offset)
throws IOException
{
int count = tempbuf.length;
byte[] buf = tempbuf;
byte sendbuf[] = new byte[3];
byte b,reply;
int boffset = 0, noffset = offset;
boolean dobreak = false;
if (count == 0) // buffer is empty.
return -1;
while(!dobreak && (boffset < count) && (noffset < nbuf.length)) {
b=buf[boffset++];
// of course, byte is a signed entity (-128 -> 127)
// but apparently the SGI Netscape 3.0 doesn't seem
// to care and provides happily values up to 255
if (b>=128)
b=(byte)(b-256);
if(debug > 2) {
Byte B = new Byte(b);
System.err.print("byte: " + B.intValue()+ " ");
}
switch (neg_state) {
case STATE_DATA:
if (b==IAC) {
neg_state = STATE_IAC;
dobreak = true; // leave the loop so we can sync.
} else
nbuf[noffset++]=b;
break;
case STATE_IAC:
switch (b) {
case IAC:
if(debug > 2) System.err.print("IAC ");
neg_state = STATE_DATA;
nbuf[noffset++]=IAC;
break;
case WILL:
if(debug > 2) System.err.print("WILL ");
neg_state = STATE_IACWILL;
break;
case WONT:
if(debug > 2) System.err.print("WONT ");
neg_state = STATE_IACWONT;
break;
case DONT:
if(debug > 2) System.err.print("DONT ");
neg_state = STATE_IACDONT;
break;
case DO:
if(debug > 2) System.err.print("DO ");
neg_state = STATE_IACDO;
break;
case EOR:
if(debug > 1) System.err.print("EOR ");
notifyEndOfRecord();
dobreak = true; // leave the loop so we can sync.
neg_state = STATE_DATA;
break;
case SB:
if(debug > 2) System.err.print("SB ");
neg_state = STATE_IACSB;
break;
default:
if(debug > 2) System.err.print("<UNKNOWN "+b+" > ");
neg_state = STATE_DATA;
break;
}
break;
case STATE_IACWILL:
switch(b) {
case TELOPT_ECHO:
if(debug > 2) System.err.println("ECHO");
reply = DO;
setLocalEcho(false);
break;
case TELOPT_SGA:
if(debug > 2) System.err.println("SGA");
reply = DO;
break;
case TELOPT_EOR:
if(debug > 2) System.err.println("EOR");
reply = DO;
break;
case TELOPT_BINARY:
if(debug > 2) System.err.println("BINARY");
reply = DO;
break;
default:
if(debug > 2) System.err.println("<UNKNOWN,"+b+">");
reply = DONT;
break;
}
if(debug > 1) System.err.println("<"+b+", WILL ="+WILL+">");
if (reply != sentDX[b+128] || WILL != receivedWX[b+128]) {
sendbuf[0]=IAC;
sendbuf[1]=reply;
sendbuf[2]=b;
write(sendbuf);
sentDX[b+128] = reply;
receivedWX[b+128] = WILL;
}
neg_state = STATE_DATA;
break;
case STATE_IACWONT:
switch(b) {
case TELOPT_ECHO:
if(debug > 2) System.err.println("ECHO");
setLocalEcho(true);
reply = DONT;
break;
case TELOPT_SGA:
if(debug > 2) System.err.println("SGA");
reply = DONT;
break;
case TELOPT_EOR:
if(debug > 2) System.err.println("EOR");
reply = DONT;
break;
case TELOPT_BINARY:
if(debug > 2) System.err.println("BINARY");
reply = DONT;
break;
default:
if(debug > 2) System.err.println("<UNKNOWN,"+b+">");
reply = DONT;
break;
}
if(reply != sentDX[b+128] || WONT != receivedWX[b+128]) {
sendbuf[0]=IAC;
sendbuf[1]=reply;
sendbuf[2]=b;
write(sendbuf);
sentDX[b+128] = reply;
receivedWX[b+128] = WILL;
}
neg_state = STATE_DATA;
break;
case STATE_IACDO:
switch (b) {
case TELOPT_ECHO:
if(debug > 2) System.err.println("ECHO");
reply = WILL;
setLocalEcho(true);
break;
case TELOPT_SGA:
if(debug > 2) System.err.println("SGA");
reply = WILL;
break;
case TELOPT_TTYPE:
if(debug > 2) System.err.println("TTYPE");
reply = WILL;
break;
case TELOPT_BINARY:
if(debug > 2) System.err.println("BINARY");
reply = WILL;
break;
case TELOPT_NAWS:
if(debug > 2) System.err.println("NAWS");
int[] size = getWindowSize();
receivedDX[b] = DO;
if(size == null) {
// this shouldn't happen
write(IAC);
write(WONT);
write(TELOPT_NAWS);
reply = WONT;
sentWX[b] = WONT;
break;
}
reply = WILL;
sentWX[b] = WILL;
sendbuf[0]=IAC;
sendbuf[1]=WILL;
sendbuf[2]=TELOPT_NAWS;
write(sendbuf);
write(IAC);write(SB);write(TELOPT_NAWS);
write((byte) (size[0] >> 8));
write((byte) (size[0] & 0xff));
write((byte) (size[1] >> 8));
write((byte) (size[1] & 0xff));
write(IAC);write(SE);
break;
default:
if(debug > 2) System.err.println("<UNKNOWN,"+b+">");
reply = WONT;
break;
}
if(reply != sentWX[128+b] || DO != receivedDX[128+b]) {
sendbuf[0]=IAC;
sendbuf[1]=reply;
sendbuf[2]=b;
write(sendbuf);
sentWX[b+128] = reply;
receivedDX[b+128] = DO;
}
neg_state = STATE_DATA;
break;
case STATE_IACDONT:
switch (b) {
case TELOPT_ECHO:
if(debug > 2) System.err.println("ECHO");
reply = WONT;
setLocalEcho(false);
break;
case TELOPT_SGA:
if(debug > 2) System.err.println("SGA");
reply = WONT;
break;
case TELOPT_NAWS:
if(debug > 2) System.err.println("NAWS");
reply = WONT;
break;
case TELOPT_BINARY:
if(debug > 2) System.err.println("BINARY");
reply = WONT;
break;
default:
if(debug > 2) System.err.println("<UNKNOWN,"+b+">");
reply = WONT;
break;
}
if(reply != sentWX[b+128] || DONT != receivedDX[b+128]) {
write(IAC);write(reply);write(b);
sentWX[b+128] = reply;
receivedDX[b+128] = DONT;
}
neg_state = STATE_DATA;
break;
case STATE_IACSBIAC:
if(debug > 2) System.err.println(""+b+" ");
if (b == IAC) {
sbbuf = new byte[0];
current_sb = b;
neg_state = STATE_IACSBDATA;
} else {
System.err.println("(bad) "+b+" ");
neg_state = STATE_DATA;
}
break;
case STATE_IACSB:
if(debug > 2) System.err.println(""+b+" ");
switch (b) {
case IAC:
neg_state = STATE_IACSBIAC;
break;
default:
current_sb = b;
sbbuf = new byte[0];
neg_state = STATE_IACSBDATA;
break;
}
break;
case STATE_IACSBDATA:
if (debug > 2) System.err.println(""+b+" ");
switch (b) {
case IAC:
neg_state = STATE_IACSBDATAIAC;
break;
default:
byte[] xsb = new byte[sbbuf.length+1];
System.arraycopy(sbbuf,0,xsb,0,sbbuf.length);
sbbuf = xsb;
sbbuf[sbbuf.length-1] = b;
break;
}
break;
case STATE_IACSBDATAIAC:
if (debug > 2) System.err.println(""+b+" ");
switch (b) {
case IAC:
neg_state = STATE_IACSBDATA;
byte[] xsb = new byte[sbbuf.length+1];
System.arraycopy(sbbuf,0,xsb,0,sbbuf.length);
sbbuf = xsb;
sbbuf[sbbuf.length-1] = IAC;
break;
case SE:
handle_sb(current_sb,sbbuf);
current_sb = 0;
neg_state = STATE_DATA;
break;
case SB:
handle_sb(current_sb,sbbuf);
neg_state = STATE_IACSB;
break;
default:
neg_state = STATE_DATA;
break;
}
break;
default:
if (debug > 1)
System.err.println("This should not happen: "+neg_state+" ");
neg_state = STATE_DATA;
break;
}
}
// shrink tempbuf to new processed size.
byte[] xb = new byte[count-boffset];
System.arraycopy(tempbuf,boffset,xb,0,count-boffset);
tempbuf = xb;
return noffset - offset;
}
public void inputfeed(byte[] b, int offset, int len) {
byte[] xb = new byte[tempbuf.length+len];
System.arraycopy(tempbuf,0,xb,0,tempbuf.length);
System.arraycopy(b,offset,xb,tempbuf.length,len);
tempbuf = xb;
}
}
| Java |
package net.sourceforge.jsocks;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
SOCKS5 request/response message.
*/
public class Socks5Message extends ProxyMessage{
/** Address type of given message*/
public int addrType;
byte[] data;
/**
Server error response.
@param cmd Error code.
*/
public Socks5Message(int cmd){
super(cmd,null,0);
data = new byte[3];
data[0] = SOCKS_VERSION; //Version.
data[1] = (byte)cmd; //Reply code for some kind of failure.
data[2] = 0; //Reserved byte.
}
/**
Construct client request or server response.
@param cmd - Request/Response code.
@param ip - IP field.
@paarm port - port field.
*/
public Socks5Message(int cmd,InetAddress ip,int port){
super(cmd,ip,port);
this.host = ip==null?"0.0.0.0":ip.getHostName();
this.version = SOCKS_VERSION;
byte[] addr;
if(ip == null){
addr = new byte[4];
addr[0]=addr[1]=addr[2]=addr[3]=0;
}else
addr = ip.getAddress();
addrType = addr.length == 4 ? SOCKS_ATYP_IPV4
: SOCKS_ATYP_IPV6;
data = new byte[6+addr.length];
data[0] = (byte) SOCKS_VERSION; //Version
data[1] = (byte) command; //Command
data[2] = (byte) 0; //Reserved byte
data[3] = (byte) addrType; //Address type
//Put Address
System.arraycopy(addr,0,data,4,addr.length);
//Put port
data[data.length-2] = (byte)(port>>8);
data[data.length-1] = (byte)(port);
}
/**
Construct client request or server response.
@param cmd - Request/Response code.
@param hostName - IP field as hostName, uses ADDR_TYPE of HOSTNAME.
@paarm port - port field.
*/
public Socks5Message(int cmd,String hostName,int port){
super(cmd,null,port);
this.host = hostName;
this.version = SOCKS_VERSION;
//System.out.println("Doing ATYP_DOMAINNAME");
addrType = SOCKS_ATYP_DOMAINNAME;
byte addr[] = hostName.getBytes();
data =new byte[7+addr.length];
data[0] = (byte) SOCKS_VERSION; //Version
data[1] = (byte) command; //Command
data[2] = (byte) 0; //Reserved byte
data[3] = (byte) SOCKS_ATYP_DOMAINNAME; //Address type
data[4] = (byte) addr.length; //Length of the address
//Put Address
System.arraycopy(addr,0,data,5,addr.length);
//Put port
data[data.length-2] = (byte)(port >>8);
data[data.length-1] = (byte)(port);
}
/**
Initialises Message from the stream. Reads server response from
given stream.
@param in Input stream to read response from.
@throws SocksException If server response code is not SOCKS_SUCCESS(0), or
if any error with protocol occurs.
@throws IOException If any error happens with I/O.
*/
public Socks5Message(InputStream in) throws SocksException,
IOException{
this(in,true);
}
/**
Initialises Message from the stream. Reads server response or client
request from given stream.
@param in Input stream to read response from.
@param clinetMode If true read server response, else read client request.
@throws SocksException If server response code is not SOCKS_SUCCESS(0) and
reading in client mode, or if any error with protocol occurs.
@throws IOException If any error happens with I/O.
*/
public Socks5Message(InputStream in,boolean clientMode)throws SocksException,
IOException{
read(in,clientMode);
}
/**
Initialises Message from the stream. Reads server response from
given stream.
@param in Input stream to read response from.
@throws SocksException If server response code is not SOCKS_SUCCESS(0), or
if any error with protocol occurs.
@throws IOException If any error happens with I/O.
*/
public void read(InputStream in) throws SocksException,
IOException{
read(in,true);
}
/**
Initialises Message from the stream. Reads server response or client
request from given stream.
@param in Input stream to read response from.
@param clinetMode If true read server response, else read client request.
@throws SocksException If server response code is not SOCKS_SUCCESS(0) and
reading in client mode, or if any error with protocol occurs.
@throws IOException If any error happens with I/O.
*/
public void read(InputStream in,boolean clientMode) throws SocksException,
IOException{
data = null;
ip = null;
DataInputStream di = new DataInputStream(in);
version = di.readUnsignedByte();
command = di.readUnsignedByte();
if(clientMode && command != 0)
throw new SocksException(command);
@SuppressWarnings("unused")
int reserved = di.readUnsignedByte();
addrType = di.readUnsignedByte();
byte addr[];
switch(addrType){
case SOCKS_ATYP_IPV4:
addr = new byte[4];
di.readFully(addr);
host = bytes2IPV4(addr,0);
break;
case SOCKS_ATYP_IPV6:
addr = new byte[SOCKS_IPV6_LENGTH];//I believe it is 16 bytes,huge!
di.readFully(addr);
host = bytes2IPV6(addr,0);
break;
case SOCKS_ATYP_DOMAINNAME:
//System.out.println("Reading ATYP_DOMAINNAME");
addr = new byte[di.readUnsignedByte()];//Next byte shows the length
di.readFully(addr);
host = new String(addr);
break;
default:
throw(new SocksException(Proxy.SOCKS_JUST_ERROR));
}
port = di.readUnsignedShort();
if(addrType != SOCKS_ATYP_DOMAINNAME && doResolveIP){
try{
ip = InetAddress.getByName(host);
}catch(UnknownHostException uh_ex){
}
}
}
/**
Writes the message to the stream.
@param out Output stream to which message should be written.
*/
public void write(OutputStream out)throws SocksException,
IOException{
if(data == null){
Socks5Message msg;
if(addrType == SOCKS_ATYP_DOMAINNAME)
msg = new Socks5Message(command,host,port);
else{
if(ip == null){
try{
ip = InetAddress.getByName(host);
}catch(UnknownHostException uh_ex){
throw new SocksException(Proxy.SOCKS_JUST_ERROR);
}
}
msg = new Socks5Message(command,ip,port);
}
data = msg.data;
}
out.write(data);
}
/**
Returns IP field of the message as IP, if the message was created
with ATYP of HOSTNAME, it will attempt to resolve the hostname,
which might fail.
@throws UnknownHostException if host can't be resolved.
*/
public InetAddress getInetAddress() throws UnknownHostException{
if(ip!=null) return ip;
return (ip=InetAddress.getByName(host));
}
/**
Returns string representation of the message.
*/
public String toString(){
String s=
"Socks5Message:"+"\n"+
"VN "+version+"\n"+
"CMD "+command+"\n"+
"ATYP "+addrType+"\n"+
"ADDR "+host+"\n"+
"PORT "+port+"\n";
return s;
}
/**
*Wether to resolve hostIP returned from SOCKS server
*that is wether to create InetAddress object from the
*hostName string
*/
static public boolean resolveIP(){ return doResolveIP;}
/**
*Wether to resolve hostIP returned from SOCKS server
*that is wether to create InetAddress object from the
*hostName string
*@param doResolve Wether to resolve hostIP from SOCKS server.
*@return Previous value.
*/
static public boolean resolveIP(boolean doResolve){
boolean old = doResolveIP;
doResolveIP = doResolve;
return old;
}
/*
private static final void debug(String s){
if(DEBUG)
System.out.print(s);
}
private static final boolean DEBUG = false;
*/
//SOCKS5 constants
public static final int SOCKS_VERSION =5;
public static final int SOCKS_ATYP_IPV4 =0x1; //Where is 2??
public static final int SOCKS_ATYP_DOMAINNAME =0x3; //!!!!rfc1928
public static final int SOCKS_ATYP_IPV6 =0x4;
public static final int SOCKS_IPV6_LENGTH =16;
static boolean doResolveIP = true;
}
| Java |
package net.sourceforge.jsocks;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
SOCKS4 Reply/Request message.
*/
public class Socks4Message extends ProxyMessage{
private byte[] msgBytes;
private int msgLength;
/**
* Server failed reply, cmd command for failed request
*/
public Socks4Message(int cmd){
super(cmd,null,0);
this.user = null;
msgLength = 2;
msgBytes = new byte[2];
msgBytes[0] = (byte) 0;
msgBytes[1] = (byte) command;
}
/**
* Server successfull reply
*/
public Socks4Message(int cmd,InetAddress ip,int port){
this(0,cmd,ip,port,null);
}
/**
* Client request
*/
public Socks4Message(int cmd,InetAddress ip,int port,String user){
this(SOCKS_VERSION,cmd,ip,port,user);
}
/**
* Most general constructor
*/
public Socks4Message(int version, int cmd,
InetAddress ip,int port,String user){
super(cmd,ip,port);
this.user = user;
this.version = version;
msgLength = user == null?8:9+user.length();
msgBytes = new byte[msgLength];
msgBytes[0] = (byte) version;
msgBytes[1] = (byte) command;
msgBytes[2] = (byte) (port >> 8);
msgBytes[3] = (byte) port;
byte[] addr;
if(ip != null)
addr = ip.getAddress();
else{
addr = new byte[4];
addr[0]=addr[1]=addr[2]=addr[3]=0;
}
System.arraycopy(addr,0,msgBytes,4,4);
if(user != null){
byte[] buf = user.getBytes();
System.arraycopy(buf,0,msgBytes,8,buf.length);
msgBytes[msgBytes.length -1 ] = 0;
}
}
/**
*Initialise from the stream
*If clientMode is true attempts to read a server response
*otherwise reads a client request
*see read for more detail
*/
public Socks4Message(InputStream in, boolean clientMode) throws IOException{
msgBytes = null;
read(in,clientMode);
}
@Override
public void read(InputStream in) throws IOException{
read(in,true);
}
@Override
public void read(InputStream in, boolean clientMode) throws IOException{
boolean mode4a = false;
DataInputStream d_in = new DataInputStream(in);
version= d_in.readUnsignedByte();
command = d_in.readUnsignedByte();
if(clientMode && command != REPLY_OK){
String errMsg;
if(command >REPLY_OK && command < REPLY_BAD_IDENTD)
errMsg = replyMessage[command-REPLY_OK];
else
errMsg = "Unknown Reply Code";
throw new SocksException(command,errMsg);
}
port = d_in.readUnsignedShort();
byte[] addr = new byte[4];
d_in.readFully(addr);
if (addr[0] == 0 && addr[1] == 0 && addr[2] == 0 && addr[3] != 0)
mode4a = true;
else {
ip=bytes2IP(addr);
host = ip.getHostName();
}
if(!clientMode){
StringBuilder sb = new StringBuilder();
int b;
while ((b = in.read()) != 0)
sb.append((char) b);
user = sb.toString();
if (mode4a) {
sb.setLength(0);
while ((b = in.read()) != 0)
sb.append((char) b);
host = sb.toString();
}
}
}
@Override
public void write(OutputStream out) throws IOException{
if(msgBytes == null){
Socks4Message msg = new Socks4Message(version,command,ip,port,user);
msgBytes = msg.msgBytes;
msgLength = msg.msgLength;
}
out.write(msgBytes);
}
//Class methods
static InetAddress bytes2IP(byte[] addr){
String s = bytes2IPV4(addr,0);
try{
return InetAddress.getByName(s);
}catch(UnknownHostException uh_ex){
return null;
}
}
//Constants
static final String[] replyMessage ={
"Request Granted",
"Request Rejected or Failed",
"Failed request, can't connect to Identd",
"Failed request, bad user name"};
static final int SOCKS_VERSION = 4;
public final static int REQUEST_CONNECT = 1;
public final static int REQUEST_BIND = 2;
public final static int REPLY_OK = 90;
public final static int REPLY_REJECTED = 91;
public final static int REPLY_NO_CONNECT = 92;
public final static int REPLY_BAD_IDENTD = 93;
}
| Java |
package net.sourceforge.jsocks;
/**
This interface provides for datagram encapsulation for SOCKSv5 protocol.
<p>
SOCKSv5 allows for datagrams to be encapsulated for purposes of integrity
and/or authenticity. How it should be done is aggreed during the
authentication stage, and is authentication dependent. This interface is
provided to allow this encapsulation.
@see Authentication
*/
public interface UDPEncapsulation{
/**
This method should provide any authentication depended transformation
on datagrams being send from/to the client.
@param data Datagram data (including any SOCKS related bytes), to be
encapsulated/decapsulated.
@param out Wether the data is being send out. If true method should
encapsulate/encrypt data, otherwise it should decapsulate/
decrypt data.
@throw IOException if for some reason data can be transformed correctly.
@return Should return byte array containing data after transformation.
It is possible to return same array as input, if transformation
only involves bit mangling, and no additional data is being
added or removed.
*/
byte[] udpEncapsulate(byte[] data, boolean out) throws java.io.IOException;
}
| Java |
package net.sourceforge.jsocks;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/**
Abstract class Proxy, base for classes Socks4Proxy and Socks5Proxy.
Defines methods for specifying default proxy, to be
used by all classes of this package.
*/
public abstract class Proxy{
//Data members
//protected InetRange directHosts = new InetRange();
protected InetAddress proxyIP = null;
protected String proxyHost = null;
protected int proxyPort;
protected Socket proxySocket = null;
protected InputStream in;
protected OutputStream out;
protected int version;
protected Proxy chainProxy = null;
//Protected static/class variables
protected static Proxy defaultProxy = null;
//Constructors
//====================
Proxy(String proxyHost, int proxyPort) throws UnknownHostException {
this.proxyHost = proxyHost;
this.proxyIP = InetAddress.getByName(proxyHost);
this.proxyPort = proxyPort;
}
Proxy(Proxy chainProxy,InetAddress proxyIP,int proxyPort){
this.chainProxy = chainProxy;
this.proxyIP = proxyIP;
this.proxyPort = proxyPort;
}
Proxy(InetAddress proxyIP,int proxyPort){
this.proxyIP = proxyIP;
this.proxyPort = proxyPort;
}
Proxy(Proxy p){
this.proxyIP = p.proxyIP;
this.proxyPort = p.proxyPort;
this.version = p.version;
}
//Public instance methods
//========================
/**
Get the port on which proxy server is running.
* @return Proxy port.
*/
public int getPort(){
return proxyPort;
}
/**
Get the ip address of the proxy server host.
* @return Proxy InetAddress.
*/
public InetAddress getInetAddress(){
return proxyIP;
}
/**
Get string representation of this proxy.
* @returns string in the form:proxyHost:proxyPort \t Version versionNumber
*/
public String toString(){
return (""+proxyIP.getHostName()+":"+proxyPort+"\tVersion "+version);
}
//Public Static(Class) Methods
//==============================
/**
* Sets SOCKS4 proxy as default.
@param hostName Host name on which SOCKS4 server is running.
@param port Port on which SOCKS4 server is running.
@param user Username to use for communications with proxy.
*/
public static void setDefaultProxy(String hostName,int port,String user)
throws UnknownHostException{
defaultProxy = new Socks4Proxy(hostName,port,user);
}
/**
* Sets SOCKS4 proxy as default.
@param ipAddress Host address on which SOCKS4 server is running.
@param port Port on which SOCKS4 server is running.
@param user Username to use for communications with proxy.
*/
public static void setDefaultProxy(InetAddress ipAddress,int port,
String user){
defaultProxy = new Socks4Proxy(ipAddress,port,user);
}
/**
* Sets SOCKS5 proxy as default.
* Default proxy only supports no-authentication.
@param hostName Host name on which SOCKS5 server is running.
@param port Port on which SOCKS5 server is running.
*/
public static void setDefaultProxy(String hostName,int port)
throws UnknownHostException{
defaultProxy = new Socks5Proxy(hostName,port);
}
/**
* Sets SOCKS5 proxy as default.
* Default proxy only supports no-authentication.
@param ipAddress Host address on which SOCKS5 server is running.
@param port Port on which SOCKS5 server is running.
*/
public static void setDefaultProxy(InetAddress ipAddress,int port){
defaultProxy = new Socks5Proxy(ipAddress,port);
}
/**
* Sets default proxy.
@param p Proxy to use as default proxy.
*/
public static void setDefaultProxy(Proxy p){
defaultProxy = p;
}
/**
Get current default proxy.
* @return Current default proxy, or null if none is set.
*/
public static Proxy getDefaultProxy(){
return defaultProxy;
}
/**
Parses strings in the form: host[:port:user:password], and creates
proxy from information obtained from parsing.
<p>
Defaults: port = 1080.<br>
If user specified but not password, creates Socks4Proxy, if user
not specified creates Socks5Proxy, if both user and password are
speciefied creates Socks5Proxy with user/password authentication.
@param proxy_entry String in the form host[:port:user:password]
@return Proxy created from the string, null if entry was somehow
invalid(host unknown for example, or empty string)
*/
public static Proxy parseProxy(String proxy_entry){
String proxy_host;
int proxy_port = 1080;
String proxy_user = null;
String proxy_password = null;
Proxy proxy;
java.util.StringTokenizer st = new java.util.StringTokenizer(
proxy_entry,":");
if(st.countTokens() < 1) return null;
proxy_host = st.nextToken();
if(st.hasMoreTokens())
try{
proxy_port = Integer.parseInt(st.nextToken().trim());
}catch(NumberFormatException nfe){}
if(st.hasMoreTokens())
proxy_user = st.nextToken();
if(st.hasMoreTokens())
proxy_password = st.nextToken();
try{
if(proxy_user == null)
proxy = new Socks5Proxy(proxy_host,proxy_port);
else if(proxy_password == null)
proxy = new Socks4Proxy(proxy_host,proxy_port,proxy_user);
else{
proxy = new Socks5Proxy(proxy_host,proxy_port);
/*
UserPasswordAuthentication upa = new UserPasswordAuthentication(
proxy_user, proxy_password);
((Socks5Proxy)proxy).setAuthenticationMethod(upa.METHOD_ID,upa);
*/
}
}catch(UnknownHostException uhe){
return null;
}
return proxy;
}
//Protected Methods
//=================
protected void startSession()throws SocksException{
try{
proxySocket = new Socket(proxyIP,proxyPort);
in = proxySocket.getInputStream();
out = proxySocket.getOutputStream();
}catch(SocksException se){
throw se;
}catch(IOException io_ex){
throw new SocksException(SOCKS_PROXY_IO_ERROR,""+io_ex);
}
}
protected abstract Proxy copy();
protected abstract ProxyMessage formMessage(int cmd,InetAddress ip,int port);
protected abstract ProxyMessage formMessage(int cmd,String host,int port)
throws UnknownHostException;
protected abstract ProxyMessage formMessage(InputStream in)
throws SocksException,
IOException;
protected ProxyMessage connect(InetAddress ip,int port)
throws SocksException{
try{
startSession();
ProxyMessage request = formMessage(SOCKS_CMD_CONNECT,
ip,port);
return exchange(request);
}catch(SocksException se){
endSession();
throw se;
}
}
protected ProxyMessage connect(String host,int port)
throws UnknownHostException,SocksException{
try{
startSession();
ProxyMessage request = formMessage(SOCKS_CMD_CONNECT,
host,port);
return exchange(request);
}catch(SocksException se){
endSession();
throw se;
}
}
protected ProxyMessage bind(InetAddress ip,int port)
throws SocksException{
try{
startSession();
ProxyMessage request = formMessage(SOCKS_CMD_BIND,
ip,port);
return exchange(request);
}catch(SocksException se){
endSession();
throw se;
}
}
protected ProxyMessage bind(String host,int port)
throws UnknownHostException,SocksException{
try{
startSession();
ProxyMessage request = formMessage(SOCKS_CMD_BIND,
host,port);
return exchange(request);
}catch(SocksException se){
endSession();
throw se;
}
}
protected ProxyMessage accept()
throws IOException,SocksException{
ProxyMessage msg;
try{
msg = formMessage(in);
}catch(InterruptedIOException iioe){
throw iioe;
}catch(IOException io_ex){
endSession();
throw new SocksException(SOCKS_PROXY_IO_ERROR,"While Trying accept:"
+io_ex);
}
return msg;
}
protected ProxyMessage udpAssociate(InetAddress ip,int port)
throws SocksException{
try{
startSession();
ProxyMessage request = formMessage(SOCKS_CMD_UDP_ASSOCIATE,
ip,port);
if(request != null)
return exchange(request);
}catch(SocksException se){
endSession();
throw se;
}
//Only get here if request was null
endSession();
throw new SocksException(SOCKS_METHOD_NOTSUPPORTED,
"This version of proxy does not support UDP associate, use version 5");
}
protected ProxyMessage udpAssociate(String host,int port)
throws UnknownHostException,SocksException{
try{
startSession();
ProxyMessage request = formMessage(SOCKS_CMD_UDP_ASSOCIATE,
host,port);
if(request != null) return exchange(request);
}catch(SocksException se){
endSession();
throw se;
}
//Only get here if request was null
endSession();
throw new SocksException(SOCKS_METHOD_NOTSUPPORTED,
"This version of proxy does not support UDP associate, use version 5");
}
protected void endSession(){
try{
if(proxySocket!=null) proxySocket.close();
proxySocket = null;
}catch(IOException io_ex){
}
}
/**
*Sends the request to SOCKS server
*/
protected void sendMsg(ProxyMessage msg)throws SocksException,
IOException{
msg.write(out);
}
/**
* Reads the reply from the SOCKS server
*/
protected ProxyMessage readMsg()throws SocksException,
IOException{
return formMessage(in);
}
/**
*Sends the request reads reply and returns it
*throws exception if something wrong with IO
*or the reply code is not zero
*/
protected ProxyMessage exchange(ProxyMessage request)
throws SocksException{
ProxyMessage reply;
try{
request.write(out);
reply = formMessage(in);
}catch(SocksException s_ex){
throw s_ex;
}catch(IOException ioe){
throw(new SocksException(SOCKS_PROXY_IO_ERROR,""+ioe));
}
return reply;
}
//Private methods
//===============
//Constants
public static final int SOCKS_SUCCESS =0;
public static final int SOCKS_FAILURE =1;
public static final int SOCKS_BADCONNECT =2;
public static final int SOCKS_BADNETWORK =3;
public static final int SOCKS_HOST_UNREACHABLE =4;
public static final int SOCKS_CONNECTION_REFUSED =5;
public static final int SOCKS_TTL_EXPIRE =6;
public static final int SOCKS_CMD_NOT_SUPPORTED =7;
public static final int SOCKS_ADDR_NOT_SUPPORTED =8;
public static final int SOCKS_NO_PROXY =1<<16;
public static final int SOCKS_PROXY_NO_CONNECT =2<<16;
public static final int SOCKS_PROXY_IO_ERROR =3<<16;
public static final int SOCKS_AUTH_NOT_SUPPORTED =4<<16;
public static final int SOCKS_AUTH_FAILURE =5<<16;
public static final int SOCKS_JUST_ERROR =6<<16;
public static final int SOCKS_DIRECT_FAILED =7<<16;
public static final int SOCKS_METHOD_NOTSUPPORTED =8<<16;
public static final int SOCKS_CMD_CONNECT =0x1;
static final int SOCKS_CMD_BIND =0x2;
static final int SOCKS_CMD_UDP_ASSOCIATE =0x3;
}
| Java |
package net.sourceforge.jsocks;
import java.net.*;
import java.io.*;
/**
SocksServerSocket allows to accept connections from one particular
host through the SOCKS4 or SOCKS5 proxy.
*/
public class SocksServerSocket extends ServerSocket{
//Data members
protected Proxy proxy;
protected String localHost;
protected InetAddress localIP;
protected int localPort;
boolean doing_direct = false;
InetAddress remoteAddr;
/**
*Creates ServerSocket capable of accepting one connection
*through the firewall, uses given proxy.
*@param host Host from which the connection should be recieved.
*@param port Port number of the primary connection.
*/
public SocksServerSocket(String host, int port) throws SocksException,
UnknownHostException, IOException {
super(0);
remoteAddr = InetAddress.getByName(host);
doDirect();
}
/**
* Creates ServerSocket capable of accepting one connection
* through the firewall, uses default Proxy.
*@param ip Host from which the connection should be recieved.
*@param port Port number of the primary connection.
*/
public SocksServerSocket(InetAddress ip, int port) throws SocksException,
IOException{
this(Proxy.defaultProxy,ip,port);
}
/**
*Creates ServerSocket capable of accepting one connection
*through the firewall, uses given proxy.
*@param ip Host from which the connection should be recieved.
*@param port Port number of the primary connection.
*/
public SocksServerSocket(Proxy p, InetAddress ip, int port)
throws SocksException, IOException {
super(0);
remoteAddr = ip;
doDirect();
}
/**
* Accepts the incoming connection.
*/
public Socket accept() throws IOException{
Socket s;
if(!doing_direct){
if(proxy == null) return null;
ProxyMessage msg = proxy.accept();
s = msg.ip == null? new SocksSocket(msg.host,msg.port,proxy)
: new SocksSocket(msg.ip,msg.port,proxy);
//Set timeout back to 0
proxy.proxySocket.setSoTimeout(0);
}else{ //Direct Connection
//Mimic the proxy behaviour,
//only accept connections from the speciefed host.
while(true){
s = super.accept();
if(s.getInetAddress().equals(remoteAddr)){
//got the connection from the right host
//Close listenning socket.
break;
}else
s.close(); //Drop all connections from other hosts
}
}
proxy = null;
//Return accepted socket
return s;
}
/**
* Closes the connection to proxy if socket have not been accepted, if
* the direct connection is used, closes direct ServerSocket. If the
* client socket have been allready accepted, does nothing.
*/
public void close() throws IOException{
super.close();
if(proxy != null) proxy.endSession();
proxy = null;
}
/**
Get the name of the host proxy is using to listen for incoming
connection.
<P>
Usefull when address is returned by proxy as the hostname.
@return the hostname of the address proxy is using to listen
for incoming connection.
*/
public String getHost(){
return localHost;
}
/**
* Get address assigned by proxy to listen for incomming
* connections, or the local machine address if doing direct
* connection.
*/
public InetAddress getInetAddress(){
if(localIP == null){
try{
localIP = InetAddress.getByName(localHost);
}catch(UnknownHostException e){
return null;
}
}
return localIP;
}
/**
* Get port assigned by proxy to listen for incoming connections, or
the port chosen by local system, if accepting directly.
*/
public int getLocalPort(){
return localPort;
}
/**
Set Timeout.
@param timeout Amount of time in milliseconds, accept should wait for
incoming connection before failing with exception.
Zero timeout implies infinity.
*/
public void setSoTimeout(int timeout) throws SocketException{
super.setSoTimeout(timeout);
if(!doing_direct) proxy.proxySocket.setSoTimeout(timeout);
}
//Private Methods
//////////////////
private void doDirect(){
doing_direct = true;
localPort = super.getLocalPort();
localIP = super.getInetAddress();
localHost = localIP.getHostName();
}
}
| Java |
package net.sourceforge.jsocks;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
Abstract class which describes SOCKS4/5 response/request.
*/
public abstract class ProxyMessage{
/** Host as an IP address */
public InetAddress ip=null;
/** SOCKS version, or version of the response for SOCKS4*/
public int version;
/** Port field of the request/response*/
public int port;
/** Request/response code as an int*/
public int command;
/** Host as string.*/
public String host=null;
/** User field for SOCKS4 request messages*/
public String user=null;
ProxyMessage(int command,InetAddress ip,int port){
this.command = command;
this.ip = ip;
this.port = port;
}
ProxyMessage(){
}
/**
Initialises Message from the stream. Reads server response from
given stream.
@param in Input stream to read response from.
@throws SocksException If server response code is not SOCKS_SUCCESS(0), or
if any error with protocol occurs.
@throws IOException If any error happens with I/O.
*/
public abstract void read(InputStream in)
throws SocksException,
IOException;
/**
Initialises Message from the stream. Reads server response or client
request from given stream.
@param in Input stream to read response from.
@param clinetMode If true read server response, else read client request.
@throws SocksException If server response code is not SOCKS_SUCCESS(0) and
reading in client mode, or if any error with protocol occurs.
@throws IOException If any error happens with I/O.
*/
public abstract void read(InputStream in,boolean client_mode)
throws SocksException,
IOException;
/**
Writes the message to the stream.
@param out Output stream to which message should be written.
*/
public abstract void write(OutputStream out)throws SocksException,
IOException;
/**
Get the Address field of this message as InetAddress object.
@return Host address or null, if one can't be determined.
*/
public InetAddress getInetAddress() throws UnknownHostException{
return ip;
}
/**
Get string representaion of this message.
@return string representation of this message.
*/
public String toString(){
return
"Proxy Message:\n"+
"Version:"+ version+"\n"+
"Command:"+ command+"\n"+
"IP: "+ ip+"\n"+
"Port: "+ port+"\n"+
"User: "+ user+"\n" ;
}
//Package methods
//////////////////
static final String bytes2IPV4(byte[] addr,int offset){
String hostName = ""+(addr[offset] & 0xFF);
for(int i = offset+1;i<offset+4;++i)
hostName+="."+(addr[i] & 0xFF);
return hostName;
}
static final String bytes2IPV6(byte[] addr,int offset){
//Have no idea how they look like!
return null;
}
}
| Java |
package net.sourceforge.jsocks.server;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PushbackInputStream;
import java.net.Socket;
import net.sourceforge.jsocks.ProxyMessage;
import net.sourceforge.jsocks.UDPEncapsulation;
/**
An implementation of ServerAuthenticator, which does <b>not</b> do
any authentication.
<P>
<FONT size="+3" color ="FF0000"> Warning!!</font><br> Should not be
used on machines which are not behind the firewall.
<p>
It is only provided to make implementing other authentication schemes
easier.<br>
For Example: <tt><pre>
class MyAuth extends socks.server.ServerAuthenticator{
...
public ServerAuthenticator startSession(java.net.Socket s){
if(!checkHost(s.getInetAddress()) return null;
return super.startSession(s);
}
boolean checkHost(java.net.Inetaddress addr){
boolean allow;
//Do it somehow
return allow;
}
}
</pre></tt>
*/
public class ServerAuthenticatorNone implements ServerAuthenticator{
static final byte[] socks5response = {5,0};
InputStream in;
OutputStream out;
/**
Creates new instance of the ServerAuthenticatorNone.
*/
public ServerAuthenticatorNone(){
this.in = null;
this.out = null;
}
/**
Constructs new ServerAuthenticatorNone object suitable for returning
from the startSession function.
@param in Input stream to return from getInputStream method.
@param out Output stream to return from getOutputStream method.
*/
public ServerAuthenticatorNone(InputStream in, OutputStream out){
this.in = in;
this.out = out;
}
/**
Grants access to everyone.Removes authentication related bytes from
the stream, when a SOCKS5 connection is being made, selects an
authentication NONE.
*/
public ServerAuthenticator startSession(Socket s)
throws IOException{
PushbackInputStream in = new PushbackInputStream(s.getInputStream());
OutputStream out = s.getOutputStream();
int version = in.read();
if(version == 5){
if(!selectSocks5Authentication(in,out,0))
return null;
}else if(version == 4){
//Else it is the request message allready, version 4
in.unread(version);
}else
return null;
return new ServerAuthenticatorNone(in,out);
}
/**
Get input stream.
@return Input stream speciefied in the constructor.
*/
public InputStream getInputStream(){
return in;
}
/**
Get output stream.
@return Output stream speciefied in the constructor.
*/
public OutputStream getOutputStream(){
return out;
}
/**
Allways returns null.
@return null
*/
public UDPEncapsulation getUdpEncapsulation(){
return null;
}
/**
Allways returns true.
*/
public boolean checkRequest(ProxyMessage msg){
return true;
}
/**
Allways returns true.
*/
public boolean checkRequest(java.net.DatagramPacket dp, boolean out){
return true;
}
/**
Does nothing.
*/
public void endSession(){
}
/**
Convinience routine for selecting SOCKSv5 authentication.
<p>
This method reads in authentication methods that client supports,
checks wether it supports given method. If it does, the notification
method is written back to client, that this method have been chosen
for authentication. If given method was not found, authentication
failure message is send to client ([5,FF]).
@param in Input stream, version byte should be removed from the stream
before calling this method.
@param out Output stream.
@param methodId Method which should be selected.
@return true if methodId was found, false otherwise.
*/
static public boolean selectSocks5Authentication(InputStream in,
OutputStream out,
int methodId)
throws IOException{
int num_methods = in.read();
if (num_methods <= 0) return false;
byte method_ids[] = new byte[num_methods];
byte response[] = new byte[2];
boolean found = false;
response[0] = (byte) 5; //SOCKS version
response[1] = (byte) 0xFF; //Not found, we are pessimistic
int bread = 0; //bytes read so far
while(bread < num_methods)
bread += in.read(method_ids,bread,num_methods-bread);
for(int i=0;i<num_methods;++i)
if(method_ids[i] == methodId){
found = true;
response[1] = (byte) methodId;
break;
}
out.write(response);
return found;
}
}
| Java |
package net.sourceforge.jsocks.server;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.DatagramPacket;
import java.net.Socket;
import net.sourceforge.jsocks.ProxyMessage;
import net.sourceforge.jsocks.UDPEncapsulation;
/**
Classes implementing this interface should provide socks server with
authentication and authorization of users.
**/
public interface ServerAuthenticator{
/**
This method is called when a new connection accepted by the server.
<p>
At this point no data have been extracted from the connection. It is
responsibility of this method to ensure that the next byte in the
stream after this method have been called is the first byte of the
socks request message. For SOCKSv4 there is no authentication data and
the first byte in the stream is part of the request. With SOCKSv5 however
there is an authentication data first. It is expected that implementaions
will process this authentication data.
<p>
If authentication was successful an instance of ServerAuthentication
should be returned, it later will be used by the server to perform
authorization and some other things. If authentication fails null should
be returned, or an exception may be thrown.
@param s Accepted Socket.
@return An instance of ServerAuthenticator to be used for this connection
or null
*/
ServerAuthenticator startSession(Socket s) throws IOException;
/**
This method should return input stream which should be used on the
accepted socket.
<p>
SOCKSv5 allows to have multiple authentication methods, and these methods
might require some kind of transformations being made on the data.
<p>
This method is called on the object returned from the startSession
function.
*/
InputStream getInputStream();
/**
This method should return output stream to use to write to the accepted
socket.
<p>
SOCKSv5 allows to have multiple authentication methods, and these methods
might require some kind of transformations being made on the data.
<p>
This method is called on the object returned from the startSession
function.
*/
OutputStream getOutputStream();
/**
This method should return UDPEncapsulation, which should be used
on the datagrams being send in/out.
<p>
If no transformation should be done on the datagrams, this method
should return null.
<p>
This method is called on the object returned from the startSession
function.
*/
UDPEncapsulation getUdpEncapsulation();
/**
This method is called when a request have been read.
<p>
Implementation should decide wether to grant request or not. Returning
true implies granting the request, false means request should be rejected.
<p>
This method is called on the object returned from the startSession
function.
@param msg Request message.
@return true to grant request, false to reject it.
*/
boolean checkRequest(ProxyMessage msg);
/**
This method is called when datagram is received by the server.
<p>
Implementaions should decide wether it should be forwarded or dropped.
It is expecteed that implementation will use datagram address and port
information to make a decision, as well as anything else. Address and
port of the datagram are always correspond to remote machine. It is
either destination or source address. If out is true address is destination
address, else it is a source address, address of the machine from which
datagram have been received for the client.
<p>
Implementaions should return true if the datagram is to be forwarded, and
false if the datagram should be dropped.
<p>
This method is called on the object returned from the startSession
function.
@param out If true the datagram is being send out(from the client),
otherwise it is an incoming datagram.
@return True to forward datagram false drop it silently.
*/
boolean checkRequest(DatagramPacket dp, boolean out);
/**
This method is called when session is completed. Either due to normal
termination or due to any error condition.
<p>
This method is called on the object returned from the startSession
function.
*/
void endSession();
}
| Java |
package net.sourceforge.jsocks;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
Proxy which describes SOCKS4 proxy.
*/
public class Socks4Proxy extends Proxy implements Cloneable{
//Data members
String user;
//Public Constructors
//====================
/**
Creates the SOCKS4 proxy
@param p Proxy to use to connect to this proxy, allows proxy chaining.
@param proxyHost Address of the proxy server.
@param proxyPort Port of the proxy server
@param user User name to use for identification purposes.
@throws UnknownHostException If proxyHost can't be resolved.
*/
public Socks4Proxy(String proxyHost,int proxyPort,String user)
throws UnknownHostException{
super(proxyHost,proxyPort);
this.user = new String(user);
version = 4;
}
/**
Creates the SOCKS4 proxy
@param p Proxy to use to connect to this proxy, allows proxy chaining.
@param proxyIP Address of the proxy server.
@param proxyPort Port of the proxy server
@param user User name to use for identification purposes.
*/
public Socks4Proxy(Proxy p,InetAddress proxyIP,int proxyPort,String user){
super(p,proxyIP,proxyPort);
this.user = new String(user);
version = 4;
}
/**
Creates the SOCKS4 proxy
@param proxyIP Address of the proxy server.
@param proxyPort Port of the proxy server
@param user User name to use for identification purposes.
*/
public Socks4Proxy(InetAddress proxyIP,int proxyPort,String user){
this(null,proxyIP,proxyPort,user);
}
//Public instance methods
//========================
/**
* Creates a clone of this proxy. Changes made to the clone should not
* affect this object.
*/
public Object clone(){
Socks4Proxy newProxy = new Socks4Proxy(proxyIP,proxyPort,user);
newProxy.chainProxy = chainProxy;
return newProxy;
}
//Public Static(Class) Methods
//==============================
//Protected Methods
//=================
protected Proxy copy(){
Socks4Proxy copy = new Socks4Proxy(proxyIP,proxyPort,user);
copy.chainProxy = chainProxy;
return copy;
}
protected ProxyMessage formMessage(int cmd,InetAddress ip,int port){
switch(cmd){
case SOCKS_CMD_CONNECT:
cmd = Socks4Message.REQUEST_CONNECT;
break;
case SOCKS_CMD_BIND:
cmd = Socks4Message.REQUEST_BIND;
break;
default:
return null;
}
return new Socks4Message(cmd,ip,port,user);
}
protected ProxyMessage formMessage(int cmd,String host,int port)
throws UnknownHostException{
return formMessage(cmd,InetAddress.getByName(host),port);
}
protected ProxyMessage formMessage(InputStream in)
throws SocksException,
IOException{
return new Socks4Message(in,true);
}
}
| Java |
package net.sourceforge.jsocks;
import java.net.*;
import java.io.*;
/**
* SocksSocket tryies to look very similar to normal Socket,
* while allowing connections through the SOCKS4 or 5 proxy.
* To use this class you will have to identify proxy you need
* to use, Proxy class allows you to set default proxy, which
* will be used by all Socks aware sockets. You can also create
* either Socks4Proxy or Socks5Proxy, and use them by passing to the
* appropriate constructors.
* <P>
* Using Socks package can be as easy as that:
*
* <pre><tt>
*
* import Socks.*;
* ....
*
* try{
* //Specify SOCKS5 proxy
* Proxy.setDefaultProxy("socks-proxy",1080);
*
* //OR you still use SOCKS4
* //Code below uses SOCKS4 proxy
* //Proxy.setDefaultProxy("socks-proxy",1080,userName);
*
* Socket s = SocksSocket("some.host.of.mine",13);
* readTimeFromSock(s);
* }catch(SocksException sock_ex){
* //Usually it will turn in more or less meaningfull message
* System.err.println("SocksException:"+sock_ex);
* }
*
* </tt></pre>
*<P>
* However if the need exist for more control, like resolving addresses
* remotely, or using some non-trivial authentication schemes, it can be done.
*/
public class SocksSocket extends Socket{
//Data members
protected Proxy proxy;
protected String localHost, remoteHost;
protected InetAddress localIP, remoteIP;
protected int localPort,remotePort;
private Socket directSock = null;
/**
* Tryies to connect to given host and port
* using default proxy. If no default proxy speciefied
* it throws SocksException with error code SOCKS_NO_PROXY.
@param host Machine to connect to.
@param port Port to which to connect.
* @see SocksSocket#SocksSocket(Proxy,String,int)
* @see Socks5Proxy#resolveAddrLocally
*/
public SocksSocket(String host,int port)
throws SocksException,UnknownHostException{
this(Proxy.defaultProxy,host,port);
}
/**
* Connects to host port using given proxy server.
@param p Proxy to use.
@param host Machine to connect to.
@param port Port to which to connect.
@throws UnknownHostException
If one of the following happens:
<ol>
<li> Proxy settings say that address should be resolved locally, but
this fails.
<li> Proxy settings say that the host should be contacted directly but
host name can't be resolved.
</ol>
@throws SocksException
If one of the following happens:
<ul>
<li> Proxy is is null.
<li> Proxy settings say that the host should be contacted directly but
this fails.
<li> Socks Server can't be contacted.
<li> Authentication fails.
<li> Connection is not allowed by the SOCKS proxy.
<li> SOCKS proxy can't establish the connection.
<li> Any IO error occured.
<li> Any protocol error occured.
</ul>
@throws IOexception if anything is wrong with I/O.
@see Socks5Proxy#resolveAddrLocally
*/
public SocksSocket(Proxy p, String host, int port) throws SocksException,
UnknownHostException {
remoteHost = host;
remotePort = port;
remoteIP = InetAddress.getByName(host);
doDirect();
}
/**
Connects to given ip and port using given Proxy server.
@param p Proxy to use.
@param ip Machine to connect to.
@param port Port to which to connect.
*/
public SocksSocket(InetAddress ip, int port) throws SocksException{
this.remoteIP = ip;
this.remotePort = port;
this.remoteHost = ip.getHostName();
doDirect();
}
/**
* These 2 constructors are used by the SocksServerSocket.
* This socket simply overrides remoteHost, remotePort
*/
protected SocksSocket(String host,int port,Proxy proxy){
this.remotePort = port;
this.proxy = proxy;
this.localIP = proxy.proxySocket.getLocalAddress();
this.localPort = proxy.proxySocket.getLocalPort();
this.remoteHost = host;
}
protected SocksSocket(InetAddress ip,int port,Proxy proxy){
remoteIP = ip;
remotePort = port;
this.proxy = proxy;
this.localIP = proxy.proxySocket.getLocalAddress();
this.localPort = proxy.proxySocket.getLocalPort();
remoteHost = remoteIP.getHostName();
}
/**
* Same as Socket
*/
public void close() throws IOException{
if(proxy!= null)proxy.endSession();
proxy = null;
}
/**
* Same as Socket
*/
public InputStream getInputStream(){
return proxy.in;
}
/**
* Same as Socket
*/
public OutputStream getOutputStream(){
return proxy.out;
}
/**
* Same as Socket
*/
public int getPort(){
return remotePort;
}
/**
* Returns remote host name, it is usefull in cases when addresses
* are resolved by proxy, and we can't create InetAddress object.
@return The name of the host this socket is connected to.
*/
public String getHost(){
return remoteHost;
}
/**
* Get remote host as InetAddress object, might return null if
* addresses are resolved by proxy, and it is not possible to resolve
* it locally
@return Ip address of the host this socket is connected to, or null
if address was returned by the proxy as DOMAINNAME and can't be
resolved locally.
*/
public InetAddress getInetAddress(){
if(remoteIP == null){
try{
remoteIP = InetAddress.getByName(remoteHost);
}catch(UnknownHostException e){
return null;
}
}
return remoteIP;
}
/**
* Get the port assigned by the proxy for the socket, not
* the port on locall machine as in Socket.
@return Port of the socket used on the proxy server.
*/
public int getLocalPort(){
return localPort;
}
/**
* Get address assigned by proxy to make a remote connection,
* it might be different from the host specified for the proxy.
* Can return null if socks server returned this address as hostname
* and it can't be resolved locally, use getLocalHost() then.
@return Address proxy is using to make a connection.
*/
public InetAddress getLocalAddress(){
if(localIP == null){
try{
localIP = InetAddress.getByName(localHost);
}catch(UnknownHostException e){
return null;
}
}
return localIP;
}
/**
Get name of the host, proxy has assigned to make a remote connection
for this socket. This method is usefull when proxy have returned
address as hostname, and we can't resolve it on this machine.
@return The name of the host proxy is using to make a connection.
*/
public String getLocalHost(){
return localHost;
}
/**
Same as socket.
*/
public void setSoLinger(boolean on,int val) throws SocketException{
proxy.proxySocket.setSoLinger(on,val);
}
/**
Same as socket.
*/
public int getSoLinger(int timeout) throws SocketException{
return proxy.proxySocket.getSoLinger();
}
/**
Same as socket.
*/
public void setSoTimeout(int timeout) throws SocketException{
proxy.proxySocket.setSoTimeout(timeout);
}
/**
Same as socket.
*/
public int getSoTimeout(int timeout) throws SocketException{
return proxy.proxySocket.getSoTimeout();
}
/**
Same as socket.
*/
public void setTcpNoDelay(boolean on) throws SocketException{
proxy.proxySocket.setTcpNoDelay(on);
}
/**
Same as socket.
*/
public boolean getTcpNoDelay() throws SocketException{
return proxy.proxySocket.getTcpNoDelay();
}
/**
Get string representation of the socket.
*/
public String toString(){
if(directSock!=null) return "Direct connection:"+directSock;
return ("Proxy:"+proxy+";"+"addr:"+remoteHost+",port:"+remotePort
+",localport:"+localPort);
}
//Private Methods
//////////////////
private void doDirect()throws SocksException{
try{
//System.out.println("IP:"+remoteIP+":"+remotePort);
directSock = new Socket(remoteIP,remotePort);
proxy.out = directSock.getOutputStream();
proxy.in = directSock.getInputStream();
proxy.proxySocket = directSock;
localIP = directSock.getLocalAddress();
localPort = directSock.getLocalPort();
}catch(IOException io_ex){
throw new SocksException(Proxy.SOCKS_DIRECT_FAILED,
"Direct connect failed:"+io_ex);
}
}
}
| Java |
package net.sourceforge.jsocks;
/**
SOCKS5 none authentication. Dummy class does almost nothing.
*/
public class AuthenticationNone implements Authentication{
public Object[] doSocksAuthentication(int methodId,
java.net.Socket proxySocket)
throws java.io.IOException{
if(methodId!=0) return null;
return new Object[] { proxySocket.getInputStream(),
proxySocket.getOutputStream()};
}
}
| Java |
package net.sourceforge.jsocks;
import net.sourceforge.jsocks.server.*;
import java.net.*;
import java.io.*;
/**
UDP Relay server, used by ProxyServer to perform udp forwarding.
*/
class UDPRelayServer implements Runnable{
DatagramSocket client_sock;
DatagramSocket remote_sock;
Socket controlConnection;
int relayPort;
InetAddress relayIP;
Thread pipe_thread1,pipe_thread2;
Thread master_thread;
ServerAuthenticator auth;
long lastReadTime;
static PrintStream log = null;
static Proxy proxy = null;
static int datagramSize = 0xFFFF;//64K, a bit more than max udp size
static int iddleTimeout = 180000;//3 minutes
/**
Constructs UDP relay server to communicate with client
on given ip and port.
@param clientIP Address of the client from whom datagrams
will be recieved and to whom they will be forwarded.
@param clientPort Clients port.
@param master_thread Thread which will be interrupted, when
UDP relay server stoppes for some reason.
@param controlConnection Socket which will be closed, before
interrupting the master thread, it is introduced due to a bug
in windows JVM which does not throw InterruptedIOException in
threads which block in I/O operation.
*/
public UDPRelayServer(InetAddress clientIP,int clientPort,
Thread master_thread,
Socket controlConnection,
ServerAuthenticator auth)
throws IOException{
this.master_thread = master_thread;
this.controlConnection = controlConnection;
this.auth = auth;
client_sock = new Socks5DatagramSocket(true,auth.getUdpEncapsulation(),
clientIP,clientPort);
relayPort = client_sock.getLocalPort();
relayIP = client_sock.getLocalAddress();
if(relayIP.getHostAddress().equals("0.0.0.0"))
relayIP = InetAddress.getLocalHost();
if(proxy == null)
remote_sock = new DatagramSocket();
else
remote_sock = new Socks5DatagramSocket(proxy,0,null);
}
//Public methods
/////////////////
/**
Sets the timeout for UDPRelay server.<br>
Zero timeout implies infinity.<br>
Default timeout is 3 minutes.
*/
static public void setTimeout(int timeout){
iddleTimeout = timeout;
}
/**
Sets the size of the datagrams used in the UDPRelayServer.<br>
Default size is 64K, a bit more than maximum possible size of the
datagram.
*/
static public void setDatagramSize(int size){
datagramSize = size;
}
/**
Port to which client should send datagram for association.
*/
public int getRelayPort(){
return relayPort;
}
/**
IP address to which client should send datagrams for association.
*/
public InetAddress getRelayIP(){
return relayIP;
}
/**
Starts udp relay server.
Spawns two threads of execution and returns.
*/
public void start() throws IOException{
remote_sock.setSoTimeout(iddleTimeout);
client_sock.setSoTimeout(iddleTimeout);
log("Starting UDP relay server on "+relayIP+":"+relayPort);
log("Remote socket "+remote_sock.getLocalAddress()+":"+
remote_sock.getLocalPort());
pipe_thread1 = new Thread(this,"pipe1");
pipe_thread2 = new Thread(this,"pipe2");
lastReadTime = System.currentTimeMillis();
pipe_thread1.start();
pipe_thread2.start();
}
/**
Stops Relay server.
<p>
Does not close control connection, does not interrupt master_thread.
*/
public synchronized void stop(){
master_thread = null;
controlConnection = null;
abort();
}
//Runnable interface
////////////////////
public void run(){
try{
if(Thread.currentThread().getName().equals("pipe1"))
pipe(remote_sock,client_sock,false);
else
pipe(client_sock,remote_sock,true);
}catch(IOException ioe){
}finally{
abort();
log("UDP Pipe thread "+Thread.currentThread().getName()+" stopped.");
}
}
//Private methods
/////////////////
private synchronized void abort(){
if(pipe_thread1 == null) return;
log("Aborting UDP Relay Server");
remote_sock.close();
client_sock.close();
if(controlConnection != null)
try{ controlConnection.close();} catch(IOException ioe){}
if(master_thread!=null) master_thread.interrupt();
pipe_thread1.interrupt();
pipe_thread2.interrupt();
pipe_thread1 = null;
}
static private void log(String s){
if(log != null){
log.println(s);
log.flush();
}
}
private void pipe(DatagramSocket from,DatagramSocket to,boolean out)
throws IOException{
byte[] data = new byte[datagramSize];
DatagramPacket dp = new DatagramPacket(data,data.length);
while(true){
try{
from.receive(dp);
lastReadTime = System.currentTimeMillis();
if(auth.checkRequest(dp,out))
to.send(dp);
}catch(UnknownHostException uhe){
log("Dropping datagram for unknown host");
}catch(InterruptedIOException iioe){
//log("Interrupted: "+iioe);
//If we were interrupted by other thread.
if(iddleTimeout == 0) return;
//If last datagram was received, long time ago, return.
long timeSinceRead = System.currentTimeMillis() - lastReadTime;
if(timeSinceRead >= iddleTimeout -100) //-100 for adjustment
return;
}
dp.setLength(data.length);
}
}
}
| Java |
package net.sourceforge.jsocks;
import java.net.*;
import java.io.*;
/**
Datagram socket to interract through the firewall.<BR>
Can be used same way as the normal DatagramSocket. One should
be carefull though with the datagram sizes used, as additional data
is present in both incomming and outgoing datagrams.
<p>
SOCKS5 protocol allows to send host address as either:
<ul>
<li> IPV4, normal 4 byte address. (10 bytes header size)
<li> IPV6, version 6 ip address (not supported by Java as for now).
22 bytes header size.
<li> Host name,(7+length of the host name bytes header size).
</ul>
As with other Socks equivalents, direct addresses are handled
transparently, that is data will be send directly when required
by the proxy settings.
<p>
<b>NOTE:</b><br>
Unlike other SOCKS Sockets, it <b>does not</b> support proxy chaining,
and will throw an exception if proxy has a chain proxy attached. The
reason for that is not my laziness, but rather the restrictions of
the SOCKSv5 protocol. Basicaly SOCKSv5 proxy server, needs to know from
which host:port datagrams will be send for association, and returns address
to which datagrams should be send by the client, but it does not
inform client from which host:port it is going to send datagrams, in fact
there is even no guarantee they will be send at all and from the same address
each time.
*/
public class Socks5DatagramSocket extends DatagramSocket{
InetAddress relayIP;
int relayPort;
Socks5Proxy proxy;
private boolean server_mode = false;
UDPEncapsulation encapsulation;
/**
Construct Datagram socket for communication over SOCKS5 proxy
server. This constructor uses default proxy, the one set with
Proxy.setDefaultProxy() method. If default proxy is not set or
it is set to version4 proxy, which does not support datagram
forwarding, throws SocksException.
*/
public Socks5DatagramSocket() throws SocksException,
IOException{
this(Proxy.defaultProxy,0,null);
}
/**
Construct Datagram socket for communication over SOCKS5 proxy
server. And binds it to the specified local port.
This constructor uses default proxy, the one set with
Proxy.setDefaultProxy() method. If default proxy is not set or
it is set to version4 proxy, which does not support datagram
forwarding, throws SocksException.
*/
public Socks5DatagramSocket(int port) throws SocksException,
IOException{
this(Proxy.defaultProxy,port,null);
}
/**
Construct Datagram socket for communication over SOCKS5 proxy
server. And binds it to the specified local port and address.
This constructor uses default proxy, the one set with
Proxy.setDefaultProxy() method. If default proxy is not set or
it is set to version4 proxy, which does not support datagram
forwarding, throws SocksException.
*/
public Socks5DatagramSocket(int port,InetAddress ip) throws SocksException,
IOException{
this(Proxy.defaultProxy,port,ip);
}
/**
Constructs datagram socket for communication over specified proxy.
And binds it to the given local address and port. Address of null
and port of 0, signify any availabale port/address.
Might throw SocksException, if:
<ol>
<li> Given version of proxy does not support UDP_ASSOCIATE.
<li> Proxy can't be reached.
<li> Authorization fails.
<li> Proxy does not want to perform udp forwarding, for any reason.
</ol>
Might throw IOException if binding dtagram socket to given address/port
fails.
See java.net.DatagramSocket for more details.
*/
public Socks5DatagramSocket(Proxy p,int port,InetAddress ip)
throws SocksException,
IOException{
super(port,ip);
if(p == null) throw new SocksException(Proxy.SOCKS_NO_PROXY);
if(!(p instanceof Socks5Proxy))
throw new SocksException(-1,"Datagram Socket needs Proxy version 5");
if(p.chainProxy != null)
throw new SocksException(Proxy.SOCKS_JUST_ERROR,
"Datagram Sockets do not support proxy chaining.");
proxy =(Socks5Proxy) p.copy();
ProxyMessage msg = proxy.udpAssociate(super.getLocalAddress(),
super.getLocalPort());
relayIP = msg.ip;
if(relayIP.getHostAddress().equals("0.0.0.0")) relayIP = proxy.proxyIP;
relayPort = msg.port;
encapsulation = proxy.udp_encapsulation;
//debug("Datagram Socket:"+getLocalAddress()+":"+getLocalPort()+"\n");
//debug("Socks5Datagram: "+relayIP+":"+relayPort+"\n");
}
/**
Used by UDPRelayServer.
*/
Socks5DatagramSocket(boolean server_mode,UDPEncapsulation encapsulation,
InetAddress relayIP,int relayPort)
throws IOException{
super();
this.server_mode = server_mode;
this.relayIP = relayIP;
this.relayPort = relayPort;
this.encapsulation = encapsulation;
this.proxy = null;
}
/**
Sends the Datagram either through the proxy or directly depending
on current proxy settings and destination address. <BR>
<B> NOTE: </B> DatagramPacket size should be at least 10 bytes less
than the systems limit.
<P>
See documentation on java.net.DatagramSocket
for full details on how to use this method.
@param dp Datagram to send.
@throws IOException If error happens with I/O.
*/
public void send(DatagramPacket dp) throws IOException{
//If the host should be accessed directly, send it as is.
if(!server_mode){
super.send(dp);
//debug("Sending directly:");
return;
}
byte[] head = formHeader(dp.getAddress(),dp.getPort());
byte[] buf = new byte[head.length + dp.getLength()];
byte[] data = dp.getData();
//Merge head and data
System.arraycopy(head,0,buf,0,head.length);
//System.arraycopy(data,dp.getOffset(),buf,head.length,dp.getLength());
System.arraycopy(data,0,buf,head.length,dp.getLength());
if(encapsulation != null)
buf = encapsulation.udpEncapsulate(buf,true);
super.send(new DatagramPacket(buf,buf.length,relayIP,relayPort));
}
/**
This method allows to send datagram packets with address type DOMAINNAME.
SOCKS5 allows to specify host as names rather than ip addresses.Using
this method one can send udp datagrams through the proxy, without having
to know the ip address of the destination host.
<p>
If proxy specified for that socket has an option resolveAddrLocally set
to true host will be resolved, and the datagram will be send with address
type IPV4, if resolve fails, UnknownHostException is thrown.
@param dp Datagram to send, it should contain valid port and data
@param host Host name to which datagram should be send.
@throws IOException If error happens with I/O, or the host can't be
resolved when proxy settings say that hosts should be resolved locally.
@see Socks5Proxy#resolveAddrLocally(boolean)
*/
public void send(DatagramPacket dp, String host) throws IOException {
dp.setAddress(InetAddress.getByName(host));
super.send(dp);
}
/**
* Receives udp packet. If packet have arrived from the proxy relay server,
* it is processed and address and port of the packet are set to the
* address and port of sending host.<BR>
* If the packet arrived from anywhere else it is not changed.<br>
* <B> NOTE: </B> DatagramPacket size should be at least 10 bytes bigger
* than the largest packet you expect (this is for IPV4 addresses).
* For hostnames and IPV6 it is even more.
@param dp Datagram in which all relevent information will be copied.
*/
public void receive(DatagramPacket dp) throws IOException{
super.receive(dp);
if(server_mode){
//Drop all datagrams not from relayIP/relayPort
int init_length = dp.getLength();
int initTimeout = getSoTimeout();
long startTime = System.currentTimeMillis();
while(!relayIP.equals(dp.getAddress()) ||
relayPort != dp.getPort()){
//Restore datagram size
dp.setLength(init_length);
//If there is a non-infinit timeout on this socket
//Make sure that it happens no matter how often unexpected
//packets arrive.
if(initTimeout != 0){
int newTimeout = initTimeout - (int)(System.currentTimeMillis() -
startTime);
if(newTimeout <= 0) throw new InterruptedIOException(
"In Socks5DatagramSocket->receive()");
setSoTimeout(newTimeout);
}
super.receive(dp);
}
//Restore timeout settings
if(initTimeout != 0) setSoTimeout(initTimeout);
}else if(!relayIP.equals(dp.getAddress()) ||
relayPort != dp.getPort())
return; // Recieved direct packet
//If the datagram is not from the relay server, return it it as is.
byte[] data;
data = dp.getData();
if(encapsulation != null)
data = encapsulation.udpEncapsulate(data,false);
int offset = 0; //Java 1.1
//int offset = dp.getOffset(); //Java 1.2
ByteArrayInputStream bIn = new ByteArrayInputStream(data,offset,
dp.getLength());
ProxyMessage msg = new Socks5Message(bIn);
dp.setPort(msg.port);
dp.setAddress(msg.getInetAddress());
//what wasn't read by the Message is the data
int data_length = bIn.available();
//Shift data to the left
System.arraycopy(data,offset+dp.getLength()-data_length,
data,offset,data_length);
dp.setLength(data_length);
}
/**
* Returns port assigned by the proxy, to which datagrams are relayed.
* It is not the same port to which other party should send datagrams.
@return Port assigned by socks server to which datagrams are send
for association.
*/
public int getLocalPort(){
if(server_mode) return super.getLocalPort();
return relayPort;
}
/**
* Address assigned by the proxy, to which datagrams are send for relay.
* It is not necesseraly the same address, to which other party should send
* datagrams.
@return Address to which datagrams are send for association.
*/
public InetAddress getLocalAddress(){
if(server_mode) return super.getLocalAddress();
return relayIP;
}
/**
* Closes datagram socket, and proxy connection.
*/
public void close(){
if(!server_mode) proxy.endSession();
super.close();
}
/**
This method checks wether proxy still runs udp forwarding service
for this socket.
<p>
This methods checks wether the primary connection to proxy server
is active. If it is, chances are that proxy continues to forward
datagrams being send from this socket. If it was closed, most likely
datagrams are no longer being forwarded by the server.
<p>
Proxy might decide to stop forwarding datagrams, in which case it
should close primary connection. This method allows to check, wether
this have been done.
<p>
You can specify timeout for which we should be checking EOF condition
on the primary connection. Timeout is in milliseconds. Specifying 0 as
timeout implies infinity, in which case method will block, until
connection to proxy is closed or an error happens, and then return false.
<p>
One possible scenario is to call isProxyactive(0) in separate thread,
and once it returned notify other threads about this event.
@param timeout For how long this method should block, before returning.
@return true if connection to proxy is active, false if eof or error
condition have been encountered on the connection.
*/
public boolean isProxyAlive(int timeout){
if(server_mode) return false;
if(proxy != null){
try{
proxy.proxySocket.setSoTimeout(timeout);
int eof = proxy.in.read();
if(eof < 0) return false; // EOF encountered.
else return true; // This really should not happen
}catch(InterruptedIOException iioe){
return true; // read timed out.
}catch(IOException ioe){
return false;
}
}
return false;
}
//PRIVATE METHODS
//////////////////
private byte[] formHeader(InetAddress ip, int port){
Socks5Message request = new Socks5Message(0,ip,port);
request.data[0] = 0;
return request.data;
}
/*======================================================================
//Mainly Test functions
//////////////////////
private String bytes2String(byte[] b){
String s="";
char[] hex_digit = { '0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F'};
for(int i=0;i<b.length;++i){
int i1 = (b[i] & 0xF0) >> 4;
int i2 = b[i] & 0xF;
s+=hex_digit[i1];
s+=hex_digit[i2];
s+=" ";
}
return s;
}
private static final void debug(String s){
if(DEBUG)
System.out.print(s);
}
private static final boolean DEBUG = true;
public static void usage(){
System.err.print(
"Usage: java Socks.SocksDatagramSocket host port [socksHost socksPort]\n");
}
static final int defaultProxyPort = 1080; //Default Port
static final String defaultProxyHost = "www-proxy"; //Default proxy
public static void main(String args[]){
int port;
String host;
int proxyPort;
String proxyHost;
InetAddress ip;
if(args.length > 1 && args.length < 5){
try{
host = args[0];
port = Integer.parseInt(args[1]);
proxyPort =(args.length > 3)? Integer.parseInt(args[3])
: defaultProxyPort;
host = args[0];
ip = InetAddress.getByName(host);
proxyHost =(args.length > 2)? args[2]
: defaultProxyHost;
Proxy.setDefaultProxy(proxyHost,proxyPort);
Proxy p = Proxy.getDefaultProxy();
p.addDirect("lux");
DatagramSocket ds = new Socks5DatagramSocket();
BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));
String s;
System.out.print("Enter line:");
s = in.readLine();
while(s != null){
byte[] data = (s+"\r\n").getBytes();
DatagramPacket dp = new DatagramPacket(data,0,data.length,
ip,port);
System.out.println("Sending to: "+ip+":"+port);
ds.send(dp);
dp = new DatagramPacket(new byte[1024],1024);
System.out.println("Trying to recieve on port:"+
ds.getLocalPort());
ds.receive(dp);
System.out.print("Recieved:\n"+
"From:"+dp.getAddress()+":"+dp.getPort()+
"\n\n"+
new String(dp.getData(),dp.getOffset(),dp.getLength())+"\n"
);
System.out.print("Enter line:");
s = in.readLine();
}
ds.close();
System.exit(1);
}catch(SocksException s_ex){
System.err.println("SocksException:"+s_ex);
s_ex.printStackTrace();
System.exit(1);
}catch(IOException io_ex){
io_ex.printStackTrace();
System.exit(1);
}catch(NumberFormatException num_ex){
usage();
num_ex.printStackTrace();
System.exit(1);
}
}else{
usage();
}
}
*/
}
| Java |
package net.sourceforge.jsocks;
/**
The Authentication interface provides for performing method specific
authentication for SOCKS5 connections.
*/
public interface Authentication{
/**
This method is called when SOCKS5 server have selected a particular
authentication method, for whch an implementaion have been registered.
<p>
This method should return an array {inputstream,outputstream
[,UDPEncapsulation]}. The reason for that is that SOCKS5 protocol
allows to have method specific encapsulation of data on the socket for
purposes of integrity or security. And this encapsulation should be
performed by those streams returned from the method. It is also possible
to encapsulate datagrams. If authentication method supports such
encapsulation an instance of the UDPEncapsulation interface should be
returned as third element of the array, otherwise either null should be
returned as third element, or array should contain only 2 elements.
@param methodId Authentication method selected by the server.
@param proxySocket Socket used to conect to the proxy.
@return Two or three element array containing
Input/Output streams which should be used on this connection.
Third argument is optional and should contain an instance
of UDPEncapsulation. It should be provided if the authentication
method used requires any encapsulation to be done on the
datagrams.
*/
Object[] doSocksAuthentication(int methodId,java.net.Socket proxySocket)
throws java.io.IOException;
}
| Java |
package net.sourceforge.jsocks;
/**
Exception thrown by various socks classes to indicate errors
with protocol or unsuccessful server responses.
*/
public class SocksException extends java.io.IOException{
private static final long serialVersionUID = 6141184566248512277L;
/**
Construct a SocksException with given error code.
<p>
Tries to look up message which corresponds to this error code.
@param errCode Error code for this exception.
*/
public SocksException(int errCode){
this.errCode = errCode;
if((errCode >> 16) == 0){
//Server reply error message
errString = errCode <= serverReplyMessage.length ?
serverReplyMessage[errCode] :
UNASSIGNED_ERROR_MESSAGE;
}else{
//Local error
errCode = (errCode >> 16) -1;
errString = errCode <= localErrorMessage.length ?
localErrorMessage[errCode] :
UNASSIGNED_ERROR_MESSAGE;
}
}
/**
Constructs a SocksException with given error code and message.
@param errCode Error code.
@param errString Error Message.
*/
public SocksException(int errCode,String errString){
this.errCode = errCode;
this.errString = errString;
}
/**
Get the error code associated with this exception.
@return Error code associated with this exception.
*/
public int getErrorCode(){
return errCode;
}
/**
Get human readable representation of this exception.
@return String represntation of this exception.
*/
public String toString(){
return errString;
}
static final String UNASSIGNED_ERROR_MESSAGE =
"Unknown error message";
static final String serverReplyMessage[] = {
"Succeeded",
"General SOCKS server failure",
"Connection not allowed by ruleset",
"Network unreachable",
"Host unreachable",
"Connection refused",
"TTL expired",
"Command not supported",
"Address type not supported" };
static final String localErrorMessage[] ={
"SOCKS server not specified",
"Unable to contact SOCKS server",
"IO error",
"None of Authentication methods are supported",
"Authentication failed",
"General SOCKS fault" };
String errString;
public int errCode;
}//End of SocksException class
| Java |
package net.sourceforge.jsocks;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PushbackInputStream;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.NoRouteToHostException;
import java.net.ServerSocket;
import java.net.Socket;
import net.sourceforge.jsocks.server.ServerAuthenticator;
/**
SOCKS4 and SOCKS5 proxy, handles both protocols simultaniously.
Implements all SOCKS commands, including UDP relaying.
<p>
In order to use it you will need to implement ServerAuthenticator
interface. There is an implementation of this interface which does
no authentication ServerAuthenticatorNone, but it is very dangerous
to use, as it will give access to your local network to anybody
in the world. One should never use this authentication scheme unless
one have pretty good reason to do so.
There is a couple of other authentication schemes in socks.server package.
@see socks.server.ServerAuthenticator
*/
public class ProxyServer implements Runnable{
ServerAuthenticator auth;
ProxyMessage msg = null;
Socket sock=null,remote_sock=null;
ServerSocket ss=null;
UDPRelayServer relayServer = null;
InputStream in,remote_in;
OutputStream out,remote_out;
int mode;
static final int START_MODE = 0;
static final int ACCEPT_MODE = 1;
static final int PIPE_MODE = 2;
static final int ABORT_MODE = 3;
static final int BUF_SIZE = 8192;
Thread pipe_thread1,pipe_thread2;
long lastReadTime;
protected static int iddleTimeout = 180000; //3 minutes
static int acceptTimeout = 180000; //3 minutes
static PrintStream log = null;
static Proxy proxy;
//Public Constructors
/////////////////////
/**
Creates a proxy server with given Authentication scheme.
@param auth Authentication scheme to be used.
*/
public ProxyServer(ServerAuthenticator auth){
this.auth = auth;
}
//Other constructors
////////////////////
protected ProxyServer(ServerAuthenticator auth,Socket s){
this.auth = auth;
this.sock = s;
mode = START_MODE;
}
//Public methods
/////////////////
/**
Set the logging stream. Specifying null disables logging.
*/
public static void setLog(OutputStream out){
if(out == null){
log = null;
}else{
log = new PrintStream(out,true);
}
UDPRelayServer.log = log;
}
/**
Set proxy.
<p>
Allows Proxy chaining so that one Proxy server is connected to another
and so on. If proxy supports SOCKSv4, then only some SOCKSv5 requests
can be handled, UDP would not work, however CONNECT and BIND will be
translated.
@param p Proxy which should be used to handle user requests.
*/
public static void setProxy(Proxy p){
proxy =p;
UDPRelayServer.proxy = proxy;
}
/**
Get proxy.
@return Proxy wich is used to handle user requests.
*/
public static Proxy getProxy(){
return proxy;
}
/**
Sets the timeout for connections, how long shoud server wait
for data to arrive before dropping the connection.<br>
Zero timeout implies infinity.<br>
Default timeout is 3 minutes.
*/
public static void setIddleTimeout(int timeout){
iddleTimeout = timeout;
}
/**
Sets the timeout for BIND command, how long the server should
wait for the incoming connection.<br>
Zero timeout implies infinity.<br>
Default timeout is 3 minutes.
*/
public static void setAcceptTimeout(int timeout){
acceptTimeout = timeout;
}
/**
Sets the timeout for UDPRelay server.<br>
Zero timeout implies infinity.<br>
Default timeout is 3 minutes.
*/
public static void setUDPTimeout(int timeout){
UDPRelayServer.setTimeout(timeout);
}
/**
Sets the size of the datagrams used in the UDPRelayServer.<br>
Default size is 64K, a bit more than maximum possible size of the
datagram.
*/
public static void setDatagramSize(int size){
UDPRelayServer.setDatagramSize(size);
}
/**
Start the Proxy server at given port.<br>
This methods blocks.
*/
public void start(int port){
start(port,5,null);
}
/**
Create a server with the specified port, listen backlog, and local
IP address to bind to. The localIP argument can be used on a multi-homed
host for a ServerSocket that will only accept connect requests to one of
its addresses. If localIP is null, it will default accepting connections
on any/all local addresses. The port must be between 0 and 65535,
inclusive. <br>
This methods blocks.
*/
public void start(int port,int backlog,InetAddress localIP){
try{
ss = new ServerSocket(port,backlog,localIP);
log("Starting SOCKS Proxy on:"+ss.getInetAddress().getHostAddress()+":"
+ss.getLocalPort());
while(true){
Socket s = ss.accept();
log("Accepted from:"+s.getInetAddress().getHostName()+":"
+s.getPort());
ProxyServer ps = new ProxyServer(auth,s);
(new Thread(ps)).start();
}
}catch(IOException ioe){
ioe.printStackTrace();
}finally{
}
}
/**
Stop server operation.It would be wise to interrupt thread running the
server afterwards.
*/
public void stop(){
try{
if(ss != null) ss.close();
}catch(IOException ioe){
}
}
//Runnable interface
////////////////////
public void run(){
switch(mode){
case START_MODE:
try{
startSession();
}catch(IOException ioe){
handleException(ioe);
//ioe.printStackTrace();
}finally{
abort();
if(auth!=null) auth.endSession();
log("Main thread(client->remote)stopped.");
}
break;
case ACCEPT_MODE:
try{
doAccept();
mode = PIPE_MODE;
pipe_thread1.interrupt(); //Tell other thread that connection have
//been accepted.
pipe(remote_in,out);
}catch(IOException ioe){
//log("Accept exception:"+ioe);
handleException(ioe);
}finally{
abort();
log("Accept thread(remote->client) stopped");
}
break;
case PIPE_MODE:
try{
pipe(remote_in,out);
}catch(IOException ioe){
}finally{
abort();
log("Support thread(remote->client) stopped");
}
break;
case ABORT_MODE:
break;
default:
log("Unexpected MODE "+mode);
}
}
//Private methods
/////////////////
private void startSession() throws IOException{
sock.setSoTimeout(iddleTimeout);
try{
auth = auth.startSession(sock);
}catch(IOException ioe){
log("Auth throwed exception:"+ioe);
auth = null;
return;
}
if(auth == null){ //Authentication failed
log("Authentication failed");
return;
}
in = auth.getInputStream();
out = auth.getOutputStream();
msg = readMsg(in);
handleRequest(msg);
}
protected void handleRequest(ProxyMessage msg)
throws IOException{
if(!auth.checkRequest(msg)) throw new
SocksException(Proxy.SOCKS_FAILURE);
if(msg.ip == null){
if(msg instanceof Socks5Message){
msg.ip = InetAddress.getByName(msg.host);
}else
throw new SocksException(Proxy.SOCKS_FAILURE);
}
log(msg);
switch(msg.command){
case Proxy.SOCKS_CMD_CONNECT:
onConnect(msg);
break;
case Proxy.SOCKS_CMD_BIND:
onBind(msg);
break;
case Proxy.SOCKS_CMD_UDP_ASSOCIATE:
onUDP(msg);
break;
default:
throw new SocksException(Proxy.SOCKS_CMD_NOT_SUPPORTED);
}
}
private void handleException(IOException ioe){
//If we couldn't read the request, return;
if(msg == null) return;
//If have been aborted by other thread
if(mode == ABORT_MODE) return;
//If the request was successfully completed, but exception happened later
if(mode == PIPE_MODE) return;
int error_code = Proxy.SOCKS_FAILURE;
if(ioe instanceof SocksException)
error_code = ((SocksException)ioe).errCode;
else if(ioe instanceof NoRouteToHostException)
error_code = Proxy.SOCKS_HOST_UNREACHABLE;
else if(ioe instanceof ConnectException)
error_code = Proxy.SOCKS_CONNECTION_REFUSED;
else if(ioe instanceof InterruptedIOException)
error_code = Proxy.SOCKS_TTL_EXPIRE;
if(error_code > Proxy.SOCKS_ADDR_NOT_SUPPORTED || error_code < 0){
error_code = Proxy.SOCKS_FAILURE;
}
sendErrorMessage(error_code);
}
private void onConnect(ProxyMessage msg) throws IOException{
Socket s;
ProxyMessage response = null;
s = new Socket(msg.ip,msg.port);
log("Connected to "+s.getInetAddress()+":"+s.getPort());
if(msg instanceof Socks5Message){
response = new Socks5Message(Proxy.SOCKS_SUCCESS,
s.getLocalAddress(),
s.getLocalPort());
}else{
response = new Socks4Message(Socks4Message.REPLY_OK,
s.getLocalAddress(),s.getLocalPort());
}
response.write(out);
startPipe(s);
}
private void onBind(ProxyMessage msg) throws IOException{
ProxyMessage response = null;
if(proxy == null)
ss = new ServerSocket(0);
else
ss = new SocksServerSocket(proxy, msg.ip, msg.port);
ss.setSoTimeout(acceptTimeout);
log("Trying accept on "+ss.getInetAddress()+":"+ss.getLocalPort());
if(msg.version == 5)
response = new Socks5Message(Proxy.SOCKS_SUCCESS,ss.getInetAddress(),
ss.getLocalPort());
else
response = new Socks4Message(Socks4Message.REPLY_OK,
ss.getInetAddress(),
ss.getLocalPort());
response.write(out);
mode = ACCEPT_MODE;
pipe_thread1 = Thread.currentThread();
pipe_thread2 = new Thread(this);
pipe_thread2.start();
//Make timeout infinit.
sock.setSoTimeout(0);
int eof=0;
try{
while((eof=in.read())>=0){
if(mode != ACCEPT_MODE){
if(mode != PIPE_MODE) return;//Accept failed
remote_out.write(eof);
break;
}
}
}catch(EOFException eofe){
//System.out.println("EOF exception");
return;//Connection closed while we were trying to accept.
}catch(InterruptedIOException iioe){
//Accept thread interrupted us.
//System.out.println("Interrupted");
if(mode != PIPE_MODE)
return;//If accept thread was not successfull return.
}finally{
//System.out.println("Finnaly!");
}
if(eof < 0)//Connection closed while we were trying to accept;
return;
//Do not restore timeout, instead timeout is set on the
//remote socket. It does not make any difference.
pipe(in,remote_out);
}
private void onUDP(ProxyMessage msg) throws IOException{
if(msg.ip.getHostAddress().equals("0.0.0.0"))
msg.ip = sock.getInetAddress();
log("Creating UDP relay server for "+msg.ip+":"+msg.port);
relayServer = new UDPRelayServer(msg.ip,msg.port,
Thread.currentThread(),sock,auth);
ProxyMessage response;
response = new Socks5Message(Proxy.SOCKS_SUCCESS,
relayServer.relayIP,relayServer.relayPort);
response.write(out);
relayServer.start();
//Make timeout infinit.
sock.setSoTimeout(0);
try{
while(in.read()>=0) /*do nothing*/;
}catch(EOFException eofe){
}
}
//Private methods
//////////////////
private void doAccept() throws IOException{
Socket s;
long startTime = System.currentTimeMillis();
while(true){
s = ss.accept();
if(s.getInetAddress().equals(msg.ip)){
//got the connection from the right host
//Close listenning socket.
ss.close();
break;
}else if(ss instanceof SocksServerSocket){
//We can't accept more then one connection
s.close();
ss.close();
throw new SocksException(Proxy.SOCKS_FAILURE);
}else{
if(acceptTimeout!=0){ //If timeout is not infinit
int newTimeout = acceptTimeout-(int)(System.currentTimeMillis()-
startTime);
if(newTimeout <= 0) throw new InterruptedIOException(
"In doAccept()");
ss.setSoTimeout(newTimeout);
}
s.close(); //Drop all connections from other hosts
}
}
//Accepted connection
remote_sock = s;
remote_in = s.getInputStream();
remote_out = s.getOutputStream();
//Set timeout
remote_sock.setSoTimeout(iddleTimeout);
log("Accepted from "+s.getInetAddress()+":"+s.getPort());
ProxyMessage response;
if(msg.version == 5)
response = new Socks5Message(Proxy.SOCKS_SUCCESS, s.getInetAddress(),
s.getPort());
else
response = new Socks4Message(Socks4Message.REPLY_OK,
s.getInetAddress(), s.getPort());
response.write(out);
}
protected ProxyMessage readMsg(InputStream in) throws IOException{
PushbackInputStream push_in;
if(in instanceof PushbackInputStream)
push_in = (PushbackInputStream) in;
else
push_in = new PushbackInputStream(in);
int version = push_in.read();
push_in.unread(version);
ProxyMessage msg;
if(version == 5){
msg = new Socks5Message(push_in,false);
}else if(version == 4){
msg = new Socks4Message(push_in,false);
}else{
throw new SocksException(Proxy.SOCKS_FAILURE);
}
return msg;
}
private void startPipe(Socket s){
mode = PIPE_MODE;
remote_sock = s;
try{
remote_in = s.getInputStream();
remote_out = s.getOutputStream();
pipe_thread1 = Thread.currentThread();
pipe_thread2 = new Thread(this);
pipe_thread2.start();
pipe(in,remote_out);
}catch(IOException ioe){
}
}
private void sendErrorMessage(int error_code){
ProxyMessage err_msg;
if(msg instanceof Socks4Message)
err_msg = new Socks4Message(Socks4Message.REPLY_REJECTED);
else
err_msg = new Socks5Message(error_code);
try{
err_msg.write(out);
}catch(IOException ioe){}
}
private synchronized void abort(){
if(mode == ABORT_MODE) return;
mode = ABORT_MODE;
try{
log("Aborting operation");
if(remote_sock != null) remote_sock.close();
if(sock != null) sock.close();
if(relayServer!=null) relayServer.stop();
if(ss!=null) ss.close();
if(pipe_thread1 != null) pipe_thread1.interrupt();
if(pipe_thread2 != null) pipe_thread2.interrupt();
}catch(IOException ioe){}
}
static final void log(String s){
if(log != null){
log.println(s);
log.flush();
}
}
static final void log(ProxyMessage msg){
log("Request version:"+msg.version+
"\tCommand: "+command2String(msg.command));
log("IP:"+msg.ip +"\tPort:"+msg.port+
(msg.version==4?"\tUser:"+msg.user:""));
}
private void pipe(InputStream in,OutputStream out) throws IOException{
lastReadTime = System.currentTimeMillis();
byte[] buf = new byte[BUF_SIZE];
int len = 0;
while(len >= 0){
try{
if(len!=0){
out.write(buf,0,len);
out.flush();
}
len= in.read(buf);
lastReadTime = System.currentTimeMillis();
}catch(InterruptedIOException iioe){
if(iddleTimeout == 0) return;//Other thread interrupted us.
long timeSinceRead = System.currentTimeMillis() - lastReadTime;
if(timeSinceRead >= iddleTimeout - 1000) //-1s for adjustment.
return;
len = 0;
}
}
}
static final String command_names[] = {"CONNECT","BIND","UDP_ASSOCIATE"};
static final String command2String(int cmd){
if(cmd > 0 && cmd < 4) return command_names[cmd-1];
else return "Unknown Command "+cmd;
}
}
| Java |
package net.sourceforge.jsocks;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.Hashtable;
/**
SOCKS5 Proxy.
*/
public class Socks5Proxy extends Proxy implements Cloneable{
//Data members
private Hashtable<Integer, Authentication> authMethods = new Hashtable<Integer, Authentication>();
private int selectedMethod;
boolean resolveAddrLocally = true;
UDPEncapsulation udp_encapsulation=null;
//Public Constructors
//====================
/**
Creates SOCKS5 proxy.
@param proxyHost Host on which a Proxy server runs.
@param proxyPort Port on which a Proxy server listens for connections.
@throws UnknownHostException If proxyHost can't be resolved.
*/
public Socks5Proxy(String proxyHost,int proxyPort)
throws UnknownHostException{
super(proxyHost,proxyPort);
version = 5;
setAuthenticationMethod(0,new AuthenticationNone());
}
/**
Creates SOCKS5 proxy.
@param proxyIP Host on which a Proxy server runs.
@param proxyPort Port on which a Proxy server listens for connections.
*/
public Socks5Proxy(InetAddress proxyIP,int proxyPort){
super(proxyIP,proxyPort);
version = 5;
setAuthenticationMethod(0,new AuthenticationNone());
}
//Public instance methods
//========================
/**
* Wether to resolve address locally or to let proxy do so.
<p>
SOCKS5 protocol allows to send host names rather then IPs in the
requests, this option controls wether the hostnames should be send
to the proxy server as names, or should they be resolved locally.
@param doResolve Wether to perform resolution locally.
@return Previous settings.
*/
public boolean resolveAddrLocally(boolean doResolve){
boolean old = resolveAddrLocally;
resolveAddrLocally = doResolve;
return old;
}
/**
Get current setting on how the addresses should be handled.
@return Current setting for address resolution.
@see Socks5Proxy#resolveAddrLocally(boolean doResolve)
*/
public boolean resolveAddrLocally(){
return resolveAddrLocally;
}
/**
Adds another authentication method.
@param methodId Authentication method id, see rfc1928
@param method Implementation of Authentication
@see Authentication
*/
public boolean setAuthenticationMethod(int methodId,
Authentication method){
if(methodId<0 || methodId > 255)
return false;
if(method == null){
//Want to remove a particular method
return (authMethods.remove(new Integer(methodId)) != null);
}else{//Add the method, or rewrite old one
authMethods.put(new Integer(methodId),method);
}
return true;
}
/**
Get authentication method, which corresponds to given method id
@param methodId Authentication method id.
@return Implementation for given method or null, if one was not set.
*/
public Authentication getAuthenticationMethod(int methodId){
Object method = authMethods.get(new Integer(methodId));
if(method == null) return null;
return (Authentication)method;
}
/**
Creates a clone of this Proxy.
*/
@SuppressWarnings("unchecked")
public Object clone(){
Socks5Proxy newProxy = new Socks5Proxy(proxyIP,proxyPort);
newProxy.authMethods = (Hashtable<Integer, Authentication>) this.authMethods.clone();
newProxy.resolveAddrLocally = resolveAddrLocally;
newProxy.chainProxy = chainProxy;
return newProxy;
}
//Public Static(Class) Methods
//==============================
//Protected Methods
//=================
protected Proxy copy(){
Socks5Proxy copy = new Socks5Proxy(proxyIP,proxyPort);
copy.authMethods = this.authMethods; //same Hash, no copy
copy.chainProxy = this.chainProxy;
copy.resolveAddrLocally = this.resolveAddrLocally;
return copy;
}
/**
*
*
*/
protected void startSession()throws SocksException{
super.startSession();
Authentication auth;
Socket ps = proxySocket; //The name is too long
try{
byte nMethods = (byte) authMethods.size(); //Number of methods
byte[] buf = new byte[2+nMethods]; //2 is for VER,NMETHODS
buf[0] = (byte) version;
buf[1] = nMethods; //Number of methods
int i=2;
Enumeration<Integer> ids = authMethods.keys();
while(ids.hasMoreElements())
buf[i++] = (byte)((Integer)ids.nextElement()).intValue();
out.write(buf);
out.flush();
int versionNumber = in.read();
selectedMethod = in.read();
if(versionNumber < 0 || selectedMethod < 0){
//EOF condition was reached
endSession();
throw(new SocksException(SOCKS_PROXY_IO_ERROR,
"Connection to proxy lost."));
}
if(versionNumber < version){
//What should we do??
}
if(selectedMethod == 0xFF){ //No method selected
ps.close();
throw ( new SocksException(SOCKS_AUTH_NOT_SUPPORTED));
}
auth = getAuthenticationMethod(selectedMethod);
if(auth == null){
//This shouldn't happen, unless method was removed by other
//thread, or the server stuffed up
throw(new SocksException(SOCKS_JUST_ERROR,
"Speciefied Authentication not found!"));
}
Object[] in_out = auth.doSocksAuthentication(selectedMethod,ps);
if(in_out == null){
//Authentication failed by some reason
throw(new SocksException(SOCKS_AUTH_FAILURE));
}
//Most authentication methods are expected to return
//simply the input/output streams associated with
//the socket. However if the auth. method requires
//some kind of encryption/decryption being done on the
//connection it should provide classes to handle I/O.
in = (InputStream) in_out[0];
out = (OutputStream) in_out[1];
if(in_out.length > 2)
udp_encapsulation = (UDPEncapsulation) in_out[2];
}catch(SocksException s_ex){
throw s_ex;
}catch(UnknownHostException uh_ex){
throw(new SocksException(SOCKS_PROXY_NO_CONNECT));
}catch(SocketException so_ex){
throw(new SocksException(SOCKS_PROXY_NO_CONNECT));
}catch(IOException io_ex){
//System.err.println(io_ex);
throw(new SocksException(SOCKS_PROXY_IO_ERROR,""+io_ex));
}
}
protected ProxyMessage formMessage(int cmd,InetAddress ip,int port){
return new Socks5Message(cmd,ip,port);
}
protected ProxyMessage formMessage(int cmd,String host,int port)
throws UnknownHostException{
if(resolveAddrLocally)
return formMessage(cmd,InetAddress.getByName(host),port);
else
return new Socks5Message(cmd,host,port);
}
protected ProxyMessage formMessage(InputStream in)
throws SocksException,
IOException{
return new Socks5Message(in);
}
}
| Java |
/**
* Originally from http://www.cornetdesign.com/files/BeanTestCase.java.txt
*/
package org.connectbot.mock;
import junit.framework.TestCase;
import java.lang.reflect.Field;
public class BeanTestCase extends TestCase {
private static final String TEST_STRING_VAL1 = "Some Value";
private static final String TEST_STRING_VAL2 = "Some Other Value";
public static void assertMeetsEqualsContract(Class<?> classUnderTest,
String[] fieldNames) {
Object o1;
Object o2;
try {
// Get Instances
o1 = classUnderTest.newInstance();
o2 = classUnderTest.newInstance();
assertTrue(
"Instances with default constructor not equal (o1.equals(o2))",
o1.equals(o2));
assertTrue(
"Instances with default constructor not equal (o2.equals(o1))",
o2.equals(o1));
Field[] fields = getFieldsByNameOrAll(classUnderTest, fieldNames);
for (int i = 0; i < fields.length; i++) {
// Reset the instances
o1 = classUnderTest.newInstance();
o2 = classUnderTest.newInstance();
Field field = fields[i];
field.setAccessible(true);
if (field.getType() == String.class) {
field.set(o1, TEST_STRING_VAL1);
} else if (field.getType() == boolean.class) {
field.setBoolean(o1, true);
} else if (field.getType() == short.class) {
field.setShort(o1, (short) 1);
} else if (field.getType() == long.class) {
field.setLong(o1, (long) 1);
} else if (field.getType() == float.class) {
field.setFloat(o1, (float) 1);
} else if (field.getType() == int.class) {
field.setInt(o1, 1);
} else if (field.getType() == byte.class) {
field.setByte(o1, (byte) 1);
} else if (field.getType() == char.class) {
field.setChar(o1, (char) 1);
} else if (field.getType() == double.class) {
field.setDouble(o1, (double) 1);
} else if (field.getType().isEnum()) {
field.set(o1, field.getType().getEnumConstants()[0]);
} else if (Object.class.isAssignableFrom(field.getType())) {
field.set(o1, field.getType().newInstance());
} else {
fail("Don't know how to set a " + field.getType().getName());
}
assertFalse("Instances with o1 having " + field.getName()
+ " set and o2 having it not set are equal", o1
.equals(o2));
field.set(o2, field.get(o1));
assertTrue(
"After setting o2 with the value of the object in o1, the two objects in the field are not equal",
field.get(o1).equals(field.get(o2)));
assertTrue(
"Instances with o1 having "
+ field.getName()
+ " set and o2 having it set to the same object of type "
+ field.get(o2).getClass().getName()
+ " are not equal", o1.equals(o2));
if (field.getType() == String.class) {
field.set(o2, TEST_STRING_VAL2);
} else if (field.getType() == boolean.class) {
field.setBoolean(o2, false);
} else if (field.getType() == short.class) {
field.setShort(o2, (short) 0);
} else if (field.getType() == long.class) {
field.setLong(o2, (long) 0);
} else if (field.getType() == float.class) {
field.setFloat(o2, (float) 0);
} else if (field.getType() == int.class) {
field.setInt(o2, 0);
} else if (field.getType() == byte.class) {
field.setByte(o2, (byte) 0);
} else if (field.getType() == char.class) {
field.setChar(o2, (char) 0);
} else if (field.getType() == double.class) {
field.setDouble(o2, (double) 1);
} else if (field.getType().isEnum()) {
field.set(o2, field.getType().getEnumConstants()[1]);
} else if (Object.class.isAssignableFrom(field.getType())) {
field.set(o2, field.getType().newInstance());
} else {
fail("Don't know how to set a " + field.getType().getName());
}
if (field.get(o1).equals(field.get(o2))) {
// Even though we have different instances, they are equal.
// Let's walk one of them
// to see if we can find a field to set
Field[] paramFields = field.get(o1).getClass()
.getDeclaredFields();
for (int j = 0; j < paramFields.length; j++) {
paramFields[j].setAccessible(true);
if (paramFields[j].getType() == String.class) {
paramFields[j].set(field.get(o1), TEST_STRING_VAL1);
}
}
}
assertFalse(
"After setting o2 with a different object than what is in o1, the two objects in the field are equal. "
+ "This is after an attempt to walk the fields to make them different",
field.get(o1).equals(field.get(o2)));
assertFalse(
"Instances with o1 having "
+ field.getName()
+ " set and o2 having it set to a different object are equal",
o1.equals(o2));
}
} catch (InstantiationException e) {
e.printStackTrace();
throw new AssertionError(
"Unable to construct an instance of the class under test");
} catch (IllegalAccessException e) {
e.printStackTrace();
throw new AssertionError(
"Unable to construct an instance of the class under test");
} catch (SecurityException e) {
e.printStackTrace();
throw new AssertionError(
"Unable to read the field from the class under test");
} catch (NoSuchFieldException e) {
e.printStackTrace();
throw new AssertionError(
"Unable to find field in the class under test");
}
}
/**
* @param classUnderTest
* @param fieldNames
* @return
* @throws NoSuchFieldException
*/
private static Field[] getFieldsByNameOrAll(Class<?> classUnderTest,
String[] fieldNames) throws NoSuchFieldException {
Field fields[];
if (fieldNames == null) {
fields = classUnderTest.getDeclaredFields();
} else {
fields = new Field[fieldNames.length];
for (int i = 0; i < fieldNames.length; i++)
fields[i] = classUnderTest.getDeclaredField(fieldNames[i]);
}
return fields;
}
public static void assertMeetsHashCodeContract(Class<?> classUnderTest,
String[] fieldNames) {
try {
Field[] fields = getFieldsByNameOrAll(classUnderTest, fieldNames);
for (int i = 0; i < fields.length; i++) {
Object o1 = classUnderTest.newInstance();
int initialHashCode = o1.hashCode();
Field field = fields[i];
field.setAccessible(true);
if (field.getType() == String.class) {
field.set(o1, TEST_STRING_VAL1);
} else if (field.getType() == boolean.class) {
field.setBoolean(o1, true);
} else if (field.getType() == short.class) {
field.setShort(o1, (short) 1);
} else if (field.getType() == long.class) {
field.setLong(o1, (long) 1);
} else if (field.getType() == float.class) {
field.setFloat(o1, (float) 1);
} else if (field.getType() == int.class) {
field.setInt(o1, 1);
} else if (field.getType() == byte.class) {
field.setByte(o1, (byte) 1);
} else if (field.getType() == char.class) {
field.setChar(o1, (char) 1);
} else if (field.getType() == double.class) {
field.setDouble(o1, (double) 1);
} else if (field.getType().isEnum()) {
field.set(o1, field.getType().getEnumConstants()[0]);
} else if (Object.class.isAssignableFrom(field.getType())) {
field.set(o1, field.getType().newInstance());
} else {
fail("Don't know how to set a " + field.getType().getName());
}
int updatedHashCode = o1.hashCode();
assertFalse(
"The field "
+ field.getName()
+ " was not taken into account for the hashCode contract ",
initialHashCode == updatedHashCode);
}
} catch (InstantiationException e) {
e.printStackTrace();
throw new AssertionError(
"Unable to construct an instance of the class under test");
} catch (IllegalAccessException e) {
e.printStackTrace();
throw new AssertionError(
"Unable to construct an instance of the class under test");
} catch (NoSuchFieldException e) {
e.printStackTrace();
throw new AssertionError(
"Unable to find field in the class under test");
}
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot.mock;
import java.io.IOException;
import java.util.Map;
import org.connectbot.bean.HostBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import org.connectbot.transport.AbsTransport;
import android.net.Uri;
/**
* @author kenny
*
*/
public class NullTransport extends AbsTransport {
/**
*
*/
public NullTransport() {
// TODO Auto-generated constructor stub
}
/**
* @param host
* @param bridge
* @param manager
*/
public NullTransport(HostBean host, TerminalBridge bridge,
TerminalManager manager) {
super(host, bridge, manager);
// TODO Auto-generated constructor stub
}
@Override
public void close() {
// TODO Auto-generated method stub
}
@Override
public void connect() {
// TODO Auto-generated method stub
}
@Override
public HostBean createHost(Uri uri) {
// TODO Auto-generated method stub
return null;
}
@Override
public void flush() throws IOException {
// TODO Auto-generated method stub
}
@Override
public String getDefaultNickname(String username, String hostname, int port) {
// TODO Auto-generated method stub
return null;
}
@Override
public int getDefaultPort() {
// TODO Auto-generated method stub
return 0;
}
@Override
public void getSelectionArgs(Uri uri, Map<String, String> selection) {
// TODO Auto-generated method stub
}
@Override
public boolean isConnected() {
// TODO Auto-generated method stub
return false;
}
@Override
public boolean isSessionOpen() {
// TODO Auto-generated method stub
return false;
}
@Override
public int read(byte[] buffer, int offset, int length) throws IOException {
// TODO Auto-generated method stub
return 0;
}
@Override
public void setDimensions(int columns, int rows, int width, int height) {
// TODO Auto-generated method stub
}
@Override
public void write(byte[] buffer) throws IOException {
// TODO Auto-generated method stub
}
@Override
public void write(int c) throws IOException {
// TODO Auto-generated method stub
}
@Override
public boolean usesNetwork() {
// TODO Auto-generated method stub
return false;
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot.mock;
import java.io.IOException;
import java.io.OutputStream;
/**
* @author Kenny Root
*
*/
public class NullOutputStream extends OutputStream {
@Override
public void write(int arg0) throws IOException {
// do nothing
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot;
import android.test.ActivityInstrumentationTestCase2;
/**
* This is a simple framework for a test of an Application. See
* {@link android.test.ApplicationTestCase ApplicationTestCase} for more
* information on how to write and extend Application tests.
* <p/>
* To run this test, you can type:
* adb shell am instrument -w \
* -e class org.connectbot.HostListActivityTest \
* org.connectbot.tests/android.test.InstrumentationTestRunner
*/
public class SettingsActivityTest extends
ActivityInstrumentationTestCase2<SettingsActivity> {
public SettingsActivityTest() {
super("org.connectbot", SettingsActivity.class);
}
public void testOpenMenu() {
SettingsActivity a = getActivity();
a.openOptionsMenu();
a.closeOptionsMenu();
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot.util;
import java.util.Arrays;
import android.test.AndroidTestCase;
/**
* @author Kenny Root
*
*/
public class PubkeyUtilsTest extends AndroidTestCase {
public void testEncodeHex_Null_Failure() throws Exception {
try {
PubkeyUtils.encodeHex(null);
fail("Should throw null pointer exception when argument is null");
} catch (NullPointerException e) {
// success
}
}
public void testEncodeHex_Success() throws Exception {
byte[] input = {(byte) 0xFF, 0x00, (byte) 0xA5, 0x5A, 0x12, 0x23};
String expected = "ff00a55a1223";
assertEquals("Encoded hex should match expected",
PubkeyUtils.encodeHex(input), expected);
}
public void testSha256_Empty_Success() throws Exception {
byte[] empty_hashed = new byte[] {
(byte) 0xe3, (byte) 0xb0, (byte) 0xc4, (byte) 0x42,
(byte) 0x98, (byte) 0xfc, (byte) 0x1c, (byte) 0x14,
(byte) 0x9a, (byte) 0xfb, (byte) 0xf4, (byte) 0xc8,
(byte) 0x99, (byte) 0x6f, (byte) 0xb9, (byte) 0x24,
(byte) 0x27, (byte) 0xae, (byte) 0x41, (byte) 0xe4,
(byte) 0x64, (byte) 0x9b, (byte) 0x93, (byte) 0x4c,
(byte) 0xa4, (byte) 0x95, (byte) 0x99, (byte) 0x1b,
(byte) 0x78, (byte) 0x52, (byte) 0xb8, (byte) 0x55,
};
final byte[] empty = new byte[] {};
assertTrue("Empty string should be equal to known test vector",
Arrays.equals(empty_hashed, PubkeyUtils.sha256(empty)));
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot;
import org.connectbot.bean.HostBean;
import org.connectbot.mock.BeanTestCase;
import android.test.AndroidTestCase;
/**
* @author Kenny Root
*
*/
public class HostBeanTest extends AndroidTestCase {
private static final String[] FIELDS = { "nickname", "username",
"hostname", "port" };
HostBean host1;
HostBean host2;
@Override
protected void setUp() throws Exception {
super.setUp();
host1 = new HostBean();
host1.setNickname("Home");
host1.setUsername("bob");
host1.setHostname("server.example.com");
host1.setPort(22);
host2 = new HostBean();
host2.setNickname("Home");
host2.setUsername("bob");
host2.setHostname("server.example.com");
host2.setPort(22);
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
}
public void testIdEquality() {
host1.setId(1);
host2.setId(1);
assertTrue(host1.equals(host2));
assertTrue(host1.hashCode() == host2.hashCode());
}
public void testIdInequality() {
host1.setId(1);
host2.setId(2);
// HostBeans shouldn't be equal when their IDs are not the same
assertFalse("HostBeans are equal when their ID is different", host1
.equals(host2));
assertFalse("HostBean hash codes are equal when their ID is different",
host1.hashCode() == host2.hashCode());
}
public void testIdEquality2() {
host1.setId(1);
host2.setId(1);
host2.setNickname("Work");
host2.setUsername("alice");
host2.setHostname("client.example.com");
assertTrue(
"HostBeans are not equal when their ID is the same but other fields are different!",
host1.equals(host2));
assertTrue(
"HostBeans hashCodes are not equal when their ID is the same but other fields are different!",
host1.hashCode() == host2.hashCode());
}
public void testBeanMeetsEqualsContract() {
BeanTestCase.assertMeetsEqualsContract(HostBean.class, FIELDS);
}
public void testBeanMeetsHashCodeContract() {
BeanTestCase.assertMeetsHashCodeContract(HostBean.class, FIELDS);
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot;
import org.connectbot.bean.SelectionArea;
import android.test.AndroidTestCase;
/**
* @author Kenny Root
*
*/
public class SelectionAreaTest extends AndroidTestCase {
private static final int WIDTH = 80;
private static final int HEIGHT = 24;
public void testCreate() {
SelectionArea sa = new SelectionArea();
assertTrue(sa.getLeft() == 0);
assertTrue(sa.getRight() == 0);
assertTrue(sa.getTop() == 0);
assertTrue(sa.getBottom() == 0);
assertTrue(sa.isSelectingOrigin());
}
public void testCheckMovement() {
SelectionArea sa = new SelectionArea();
sa.setBounds(WIDTH, HEIGHT);
sa.incrementColumn();
// Should be (1,0) to (1,0)
assertTrue(sa.getLeft() == 1);
assertTrue(sa.getTop() == 0);
assertTrue(sa.getRight() == 1);
assertTrue(sa.getBottom() == 0);
sa.finishSelectingOrigin();
assertFalse(sa.isSelectingOrigin());
sa.incrementColumn();
sa.incrementColumn();
// Should be (1,0) to (3,0)
assertTrue(sa.getLeft() == 1);
assertTrue(sa.getTop() == 0);
assertTrue(sa.getRight() == 3);
assertTrue(sa.getBottom() == 0);
}
public void testBounds() {
SelectionArea sa = new SelectionArea();
sa.setBounds(WIDTH, HEIGHT);
for (int i = 0; i <= WIDTH; i++)
sa.decrementColumn();
assertTrue("Left bound should be 0, but instead is " + sa.getLeft(),
sa.getLeft() == 0);
for (int i = 0; i <= HEIGHT; i++)
sa.decrementRow();
assertTrue("Top bound should be 0, but instead is " + sa.getLeft(),
sa.getTop() == 0);
sa.finishSelectingOrigin();
for (int i = 0; i <= WIDTH * 2; i++)
sa.incrementColumn();
assertTrue("Left bound should be 0, but instead is " + sa.getLeft(),
sa.getLeft() == 0);
assertTrue("Right bound should be " + (WIDTH - 1) + ", but instead is " + sa.getRight(),
sa.getRight() == (WIDTH - 1));
for (int i = 0; i <= HEIGHT * 2; i++)
sa.incrementRow();
assertTrue("Bottom bound should be " + (HEIGHT - 1) + ", but instead is " + sa.getBottom(),
sa.getBottom() == (HEIGHT - 1));
assertTrue("Top bound should be 0, but instead is " + sa.getTop(),
sa.getTop() == 0);
}
public void testSetThenMove() {
SelectionArea sa = new SelectionArea();
sa.setBounds(WIDTH, HEIGHT);
int targetColumn = WIDTH / 2;
int targetRow = HEIGHT / 2;
sa.setColumn(targetColumn);
sa.setRow(targetRow);
sa.incrementRow();
assertTrue("Row should be " + (targetRow + 1) + ", but instead is " + sa.getTop(),
sa.getTop() == (targetRow + 1));
sa.decrementColumn();
assertTrue("Column shold be " + (targetColumn - 1) + ", but instead is " + sa.getLeft(),
sa.getLeft() == (targetColumn - 1));
sa.finishSelectingOrigin();
sa.setRow(0);
sa.setColumn(0);
sa.incrementRow();
sa.decrementColumn();
assertTrue("Top row should be 1, but instead is " + sa.getTop(),
sa.getTop() == 1);
assertTrue("Left column shold be 0, but instead is " + sa.getLeft(),
sa.getLeft() == 0);
assertTrue("Bottom row should be " + (targetRow + 1) + ", but instead is " + sa.getBottom(),
sa.getBottom() == (targetRow + 1));
assertTrue("Right column shold be " + (targetColumn - 1) + ", but instead is " + sa.getRight(),
sa.getRight() == (targetColumn - 1));
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot;
import android.app.Activity;
import android.test.ActivityInstrumentationTestCase2;
/**
* This is a simple framework for a test of an Application. See
* {@link android.test.ApplicationTestCase ApplicationTestCase} for more
* information on how to write and extend Application tests.
* <p/>
* To run this test, you can type: adb shell am instrument -w \ -e class
* org.connectbot.HostListActivityTest \
* org.connectbot.tests/android.test.InstrumentationTestRunner
*/
public class HostListActivityTest extends ActivityInstrumentationTestCase2<HostListActivity> {
private Activity mActivity;
public HostListActivityTest() {
super("org.connectbot", HostListActivity.class);
}
@Override
protected void setUp() throws Exception {
super.setUp();
setActivityInitialTouchMode(false);
mActivity = getActivity();
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2007 Kenny Root, Jeffrey Sharkey
*
* Licensed 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.connectbot;
import android.test.AndroidTestCase;
/**
* @author Kenny Root
*
*/
public class TerminalBridgeTest extends AndroidTestCase {
public void testShiftLock() throws SecurityException, NoSuchFieldException,
IllegalArgumentException, IllegalAccessException {
// TerminalBridge bridge = new TerminalBridge();
// AbsTransport nullTransport = new NullTransport();
//
// // Make sure onKey will work when we call it
// Field disconnected = TerminalBridge.class
// .getDeclaredField("disconnected");
// Field keymode = TerminalBridge.class.getDeclaredField("keymode");
// Field transport = TerminalBridge.class.getDeclaredField("transport");
//
// disconnected.setAccessible(true);
// keymode.setAccessible(true);
// transport.setAccessible(true);
//
// disconnected.setBoolean(bridge, false);
// keymode.set(bridge, PreferenceConstants.KEYMODE_RIGHT);
// transport.set(bridge, nullTransport);
//
// // Begin tests
// assertTrue("Meta state is " + bridge.getMetaState()
// + " when it should be 0", bridge.getMetaState() == 0);
//
// KeyEvent shiftDown = new KeyEvent(KeyEvent.ACTION_DOWN,
// KeyEvent.KEYCODE_SHIFT_LEFT);
// bridge.onKey(null, shiftDown.getKeyCode(), shiftDown);
//
// assertTrue("Shift test: after shift press, meta state is "
// + bridge.getMetaState() + " when it should be "
// + TerminalBridge.META_SHIFT_ON,
// bridge.getMetaState() == TerminalBridge.META_SHIFT_ON);
//
// KeyEvent shiftUp = KeyEvent.changeAction(shiftDown, KeyEvent.ACTION_UP);
// bridge.onKey(null, shiftUp.getKeyCode(), shiftUp);
//
// assertTrue("Shift test: after shift release, meta state is "
// + bridge.getMetaState() + " when it should be "
// + TerminalBridge.META_SHIFT_ON,
// bridge.getMetaState() == TerminalBridge.META_SHIFT_ON);
//
// KeyEvent letterAdown = new KeyEvent(KeyEvent.ACTION_DOWN,
// KeyEvent.KEYCODE_A);
// KeyEvent letterAup = KeyEvent.changeAction(letterAdown,
// KeyEvent.ACTION_UP);
//
// bridge.onKey(null, letterAdown.getKeyCode(), letterAdown);
// bridge.onKey(null, letterAup.getKeyCode(), letterAup);
//
// assertTrue("Shift test: after letter press and release, meta state is "
// + bridge.getMetaState() + " when it should be 0", bridge
// .getMetaState() == 0);
//
// bridge.onKey(null, shiftDown.getKeyCode(), shiftDown);
// bridge.onKey(null, shiftUp.getKeyCode(), shiftUp);
// bridge.onKey(null, shiftDown.getKeyCode(), shiftDown);
// bridge.onKey(null, shiftUp.getKeyCode(), shiftUp);
//
// assertTrue("Shift lock test: after two shift presses, meta state is "
// + bridge.getMetaState() + " when it should be "
// + TerminalBridge.META_SHIFT_LOCK,
// bridge.getMetaState() == TerminalBridge.META_SHIFT_LOCK);
//
// bridge.onKey(null, letterAdown.getKeyCode(), letterAdown);
//
// assertTrue(
// "Shift lock test: after letter press, meta state is "
// + bridge.getMetaState() + " when it should be "
// + TerminalBridge.META_SHIFT_LOCK,
// bridge.getMetaState() == TerminalBridge.META_SHIFT_LOCK);
//
// bridge.onKey(null, letterAup.getKeyCode(), letterAup);
//
// assertTrue(
// "Shift lock test: after letter press and release, meta state is "
// + bridge.getMetaState() + " when it should be "
// + TerminalBridge.META_SHIFT_LOCK,
// bridge.getMetaState() == TerminalBridge.META_SHIFT_LOCK);
}
}
| Java |
package com.akilesa.dictcreator;
import java.io.FileReader;
import java.io.IOException;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 19.01.2010
* Time: 11:20:36
* To change this template use File | Settings | File Templates.
*/
/**
* NAME:
* <p/>
* DESCRIPTION:
* -f - exclude words with frequency 1
*/
public class DictCreatorApp {
private static final String EXCLUDE_FREQUENCY_ONE_OPTION = "-f";
private static final String PRINT_TO_CONSOLE_OPTION = "-c";
private static Map<String, Boolean> parameters = new HashMap<String, Boolean>();
public static void main(String[] args) {
prepareParameters(args);
String filename = args[args.length - 2];
EnglishWordTokenizer tokenizer = new EnglishWordTokenizer();
try {
EnglishWordTokenizerResult result = tokenizer.divideOnWords(readFromFile(filename));
if (parameters.get(EXCLUDE_FREQUENCY_ONE_OPTION)) {
result.excludeFrequencyOne();
}
if (parameters.get(PRINT_TO_CONSOLE_OPTION)) {
result.printToConsole();
}
AnkiCardsCreator creator=new AnkiCardsCreator();
List<AnkiCard> cards=creator.create(result);
AnkiDbManagerImpl dbManager=new AnkiDbManagerImpl();
String deckName=args[args.length-1];
dbManager.createAnkiDeck(deckName);
dbManager.createCards(cards,deckName);
Statistic.getInstance().print();
} catch (IOException e) {
System.out.println("Can't open file " + filename);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
protected static String readFromFile(String filename) throws IOException {
FileReader reader = null;
try {
reader = new FileReader(filename);
String result = "";
char[] buf = new char[1000];
while (reader.ready()) {
int count = reader.read(buf);
result += new String(buf, 0, count);
}
return result;
} finally {
reader.close();
}
}
protected static void prepareParameters(String[] args) {
if (args.length > 2) {
for (int i = 0; i < args.length - 2; i++) {
if (args[i].equals(EXCLUDE_FREQUENCY_ONE_OPTION)) {
parameters.put(EXCLUDE_FREQUENCY_ONE_OPTION, true);
} else {
parameters.put(EXCLUDE_FREQUENCY_ONE_OPTION, false);
}
if (args[i].equals(PRINT_TO_CONSOLE_OPTION)) {
parameters.put(PRINT_TO_CONSOLE_OPTION, true);
} else {
parameters.put(PRINT_TO_CONSOLE_OPTION, false);
}
}
} else {
System.out.println("Parameters File name and Deck name must be defined");
System.exit(1);
}
}
}
| Java |
package com.akilesa.dictcreator;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.methods.GetMethod;
import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.nodes.TagNode;
import org.htmlparser.tags.Div;
import org.htmlparser.tags.ParagraphTag;
import org.htmlparser.util.NodeList;
import org.htmlparser.util.ParserException;
import org.htmlparser.visitors.TextExtractingVisitor;
import java.io.IOException;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 26.01.2010
* Time: 15:37:37
* To change this template use File | Settings | File Templates.
*/
public class LingvoOnlineDictionarySupport implements OnlineDictionarySupport {
private static final String GET_URL = "http://lingvo.abbyyonline.com/ru/en-ru";
private Parser parser = new Parser();
public String requestHtmlWithWordTranslation(String word) {
String result = null;
HttpClient httpClient = new HttpClient();
HttpMethod method = new GetMethod(GET_URL + "/" + word);
try {
httpClient.executeMethod(method);
result = method.getResponseBodyAsString();
method.releaseConnection();
} catch (IOException e) {
throw new RuntimeException(e);
}
return result;
}
public String parseAndGetWordTranslation(String html) {
String result = "";
try {
parser = new Parser(html);
NodeList list = parser.extractAllNodesThatMatch(new NodeFilter() {
public boolean accept(Node node) {
if (node instanceof Div) {
String className = ((Div) node).getAttribute("class");
if ("lol-card-content".equalsIgnoreCase(className)) {
return true;
}
}
return false;
}
});
for (int i = 0; i < list.size(); i++) {
result += getDictCard(list.elementAt(i));
}
} catch (ParserException e) {
throw new RuntimeException(e);
}
return result;
}
private String getDictCard(Node elem) throws ParserException {
String result = "<div style=\"text-align:left\">";
TagNode node = (Div) elem;
NodeList list = node.getChildren();
for (int i = 0; i < list.size(); i++) {
if (list.elementAt(i) instanceof Div
&& ((Div) list.elementAt(i)).getAttribute("class").equalsIgnoreCase("card-short")) {
list = list.elementAt(i).getChildren();
int pNum = 0;
for (int j = 0; j < list.size(); j++) {
if (list.elementAt(j) instanceof ParagraphTag
&& ((ParagraphTag) list.elementAt(j)).getAttribute("class").equalsIgnoreCase("P")) {
pNum++;
if (pNum > 1) {
result = result + extractText(list.elementAt(j));
}
continue;
}
if (list.elementAt(j) instanceof ParagraphTag
&& ((ParagraphTag) list.elementAt(j)).getAttribute("class").equalsIgnoreCase("P1")) {
result = result + extractText(list.elementAt(j));
}
}
break;
}
}
result+="</div>";
return result;
}
private String extractText(Node elem) throws ParserException {
String result = "";
TagNode node = (TagNode) elem;
parser = new Parser(node.toHtml());
TextExtractingVisitor visitor = new TextExtractingVisitor();
parser.visitAllNodesWith(visitor);
result = result + visitor.getExtractedText() + "<BR>";
return result;
}
}
| Java |
package com.akilesa.dictcreator;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 20.01.2010
* Time: 13:28:25
* To change this template use File | Settings | File Templates.
*/
public class AnkiCard {
private String question=" ";
private String answer=" ";
public AnkiCard() {
}
public AnkiCard(String question, String answer) {
this.question = question;
this.answer = answer;
}
public String getQuestion() {
return question;
}
public void setQuestion(String question) {
this.question = question;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
AnkiCard ankiCard = (AnkiCard) o;
if (answer != null ? !answer.equals(ankiCard.answer) : ankiCard.answer != null) return false;
if (question != null ? !question.equals(ankiCard.question) : ankiCard.question != null) return false;
return true;
}
@Override
public int hashCode() {
int result = question != null ? question.hashCode() : 0;
result = 31 * result + (answer != null ? answer.hashCode() : 0);
return result;
}
}
| Java |
package com.akilesa.dictcreator;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 26.01.2010
* Time: 15:32:55
* To change this template use File | Settings | File Templates.
*/
public interface OnlineDictionarySupport {
String requestHtmlWithWordTranslation(String word);
String parseAndGetWordTranslation(String html);
}
| Java |
package com.akilesa.dictcreator;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 19.01.2010
* Time: 11:25:31
* To change this template use File | Settings | File Templates.
*/
public class EnglishWordTokenizer {
private static final String regexp="[a-zA-Z]+";
public EnglishWordTokenizerResult divideOnWords(String text){
//TODO optimize it
EnglishWordTokenizerResult result=new EnglishWordTokenizerResult();
Map<String,Long> map=new HashMap<String,Long>();
Pattern pattern=Pattern.compile(regexp);
Matcher matcher=pattern.matcher(text);
while(matcher.find()){
String w=matcher.group().toLowerCase();
Long count=map.get(w);
if(count!=null){
map.put(w,++count);
}else{
map.put(w,1L);
}
}
List<String> list=new ArrayList<String>();
list.addAll(map.keySet());
Collections.sort(list);
for(String item : list){
EnglishWordTokenizerResult.WordDescription word=
new EnglishWordTokenizerResult.WordDescription();
word.setCount(map.get(item));
word.setWord(item);
result.getWords().add(word);
}
Statistic.getInstance().setWordTotalCount(result.getTotal());
return result;
}
}
| Java |
package com.akilesa.dictcreator;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 26.01.2010
* Time: 15:11:58
* To change this template use File | Settings | File Templates.
*/
public class OnlineDictionary {
OnlineDictionarySupport support=new LingvoOnlineDictionarySupport();
public String translate(String word) {
String html=support.requestHtmlWithWordTranslation(word);
return support.parseAndGetWordTranslation(html);
}
}
| Java |
package com.akilesa.dictcreator;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 28.01.2010
* Time: 15:04:35
* To change this template use File | Settings | File Templates.
*/
public class Statistic {
private static Statistic stat=new Statistic();
private long wordTotalCount;
private long cardTotalCount;
private long wordNotFoundCount;
private long wordExcludedTotalCount;
private long wordExcludedCount;
private Statistic(){
}
public static Statistic getInstance(){
return stat;
}
public void print(){
System.out.println("-------------------------------------------------------------------------");
System.out.println("Total count of unique words in text: "+wordTotalCount);
System.out.println("Total count of words, that was not found in dictionary: "+wordNotFoundCount);
System.out.println("Total count of words in excluded list: "+wordExcludedTotalCount);
System.out.println("Total count of words, that was excluded: "+wordExcludedCount);
System.out.println("Total count of created Anki cards: "+cardTotalCount);
System.out.println("-------------------------------------------------------------------------");
}
public static Statistic getStat() {
return stat;
}
public static void setStat(Statistic stat) {
Statistic.stat = stat;
}
public long getWordTotalCount() {
return wordTotalCount;
}
public void setWordTotalCount(long wordTotalCount) {
this.wordTotalCount = wordTotalCount;
}
public long getCardTotalCount() {
return cardTotalCount;
}
public void setCardTotalCount(long cardTotalCount) {
this.cardTotalCount = cardTotalCount;
}
public long getWordNotFoundCount() {
return wordNotFoundCount;
}
public void setWordNotFoundCount(long wordNotFoundCount) {
this.wordNotFoundCount = wordNotFoundCount;
}
public long getWordExcludedTotalCount() {
return wordExcludedTotalCount;
}
public void setWordExcludedTotalCount(long wordExcludedTotalCount) {
this.wordExcludedTotalCount = wordExcludedTotalCount;
}
public long getWordExcludedCount() {
return wordExcludedCount;
}
public void setWordExcludedCount(long wordExcludedCount) {
this.wordExcludedCount = wordExcludedCount;
}
}
| Java |
package com.akilesa.dictcreator;
import java.io.*;
import java.sql.*;
import java.util.Calendar;
import java.util.List;
import static java.lang.Class.forName;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 20.01.2010
* Time: 12:28:21
* To change this template use File | Settings | File Templates.
*/
public class AnkiDbManagerImpl {
static {
try {
forName("org.sqlite.JDBC");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
public void createAnkiDeck(String filename) throws IOException {
InputStream in = null;
OutputStream out = null;
try {
in = AnkiDbManagerImpl.class.getClassLoader().getResourceAsStream("empty.anki");
File file = new File(filename);
file.createNewFile();
out = new FileOutputStream(file);
byte[] buf = new byte[in.available()];
in.read(buf);
out.write(buf);
} finally {
in.close();
out.close();
}
}
public void createCards(List<AnkiCard> cards, String dbName) throws SQLException {
Connection connection = null;
PreparedStatement statement1 = null;
PreparedStatement statement2 = null;
ResultSet rs = null;
ResultSet generatedKeys = null;
try {
connection = DriverManager.getConnection("jdbc:sqlite:" + dbName);
statement1 =
connection.prepareStatement
("insert into cards (ordinal, question, answer, factId,cardModelId," +
"created, modified,tags,priority,interval,lastInterval,due,lastDue," +
"factor,lastFactor,firstAnswered,reps,successive,averageTime," +
"reviewTime,youngEase0,youngEase1,youngEase2,youngEase3,youngEase4," +
"matureEase0,matureEase1,matureEase2,matureEase3,matureEase4,yesCount," +
"noCount,spaceUntil,relativeDelay,isDue,type,combinedDue) " +
"values(?,?,?,?,?,?,?,?,?,?,?,1264159133.136485,0,2.5," +
"2.5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1264159133.136485)");
statement1.setQueryTimeout(30);
statement2 =
connection.prepareStatement
("insert into facts (modelId, created, modified, tags,spaceUntil) values(?,?,?,?,?)",
Statement.RETURN_GENERATED_KEYS);
statement2.setQueryTimeout(30);
rs = connection.createStatement().executeQuery("select id from models");
rs.next();
long modelId = rs.getLong(1);
rs = connection.createStatement().executeQuery("select id from cardModels where name like 'Forward'");
rs.next();
long cardModelId = rs.getLong(1);
for (int i = 0; i < cards.size(); i++) {
statement2.setLong(1, modelId);
statement2.setFloat(2, Calendar.getInstance().getTime().getTime());
statement2.setFloat(3, Calendar.getInstance().getTime().getTime());
statement2.setString(4, " ");
statement2.setFloat(5, 0);
if (statement2.executeUpdate() == 0) {
throw new RuntimeException("Can not insert values");
}
generatedKeys = statement2.getGeneratedKeys();
long factId = 0;
if (generatedKeys.next()) {
factId = generatedKeys.getLong(1);
} else {
throw new RuntimeException("Can not insert values");
}
statement1.setInt(1, i);
statement1.setString(2, cards.get(i).getQuestion());
statement1.setString(3, cards.get(i).getAnswer());
statement1.setLong(4, factId);
statement1.setLong(5, cardModelId);
statement1.setFloat(6, Calendar.getInstance().getTime().getTime());
statement1.setFloat(7, Calendar.getInstance().getTime().getTime());
statement1.setString(8, " ");
statement1.setLong(9, 2);
statement1.setFloat(10, 0);
statement1.setFloat(11, 0);
statement1.executeUpdate();
}
} finally {
try {
if (rs != null) {
rs.close();
}
if (generatedKeys != null) {
generatedKeys.close();
}
if (statement1 != null) {
statement1.close();
}
if (statement2 != null) {
statement2.close();
}
if (connection != null) {
connection.close();
}
}
catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
}
| Java |
package com.akilesa.dictcreator;
import java.util.ArrayList;
import java.util.List;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 19.01.2010
* Time: 11:47:40
* To change this template use File | Settings | File Templates.
*/
public class EnglishWordTokenizerResult {
private List<WordDescription> words = new ArrayList<WordDescription>();
public void printToConsole() {
System.out.println("Total words: " + getTotal());
for (WordDescription item : words) {
item.printToConsole();
}
}
public void excludeFrequencyOne() {
List<WordDescription> removal = new ArrayList<WordDescription>();
for (WordDescription item : words) {
if (item.getCount() == 1) {
removal.add(item);
}
}
words.removeAll(removal);
Statistic.getInstance().setWordExcludedCount(Statistic.getInstance().getWordExcludedCount() + removal.size());
}
public static class WordDescription {
private String word;
private long count;
WordDescription() {
}
WordDescription(String word, long count) {
this.count = count;
this.word = word;
}
public void printToConsole() {
System.out.println(word + "\t" + count);
}
public String getWord() {
return word;
}
public void setWord(String word) {
this.word = word;
}
public long getCount() {
return count;
}
public void setCount(long count) {
this.count = count;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
WordDescription that = (WordDescription) o;
if (count != that.count) return false;
if (word != null ? !word.equals(that.word) : that.word != null) return false;
return true;
}
@Override
public int hashCode() {
int result = word != null ? word.hashCode() : 0;
result = 31 * result + (int) (count ^ (count >>> 32));
return result;
}
}
public long getTotal() {
return words.size();
}
public List<WordDescription> getWords() {
return words;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EnglishWordTokenizerResult that = (EnglishWordTokenizerResult) o;
if (words != null ? !words.equals(that.words) : that.words != null) return false;
return true;
}
@Override
public int hashCode() {
return words != null ? words.hashCode() : 0;
}
}
| Java |
package com.akilesa.dictcreator;
import java.util.ArrayList;
import java.util.List;
/**
* Created by IntelliJ IDEA.
* User: akilesa
* Date: 21.01.2010
* Time: 11:49:00
* To change this template use File | Settings | File Templates.
*/
public class AnkiCardsCreator {
OnlineDictionary dict=new OnlineDictionary();
public List<AnkiCard> create(EnglishWordTokenizerResult tokens){
long notFounded=0;
List<AnkiCard> result=new ArrayList<AnkiCard>();
for(EnglishWordTokenizerResult.WordDescription item: tokens.getWords()){
System.out.print("\u001B[0J");
System.out.print("Processing of word "+item.getWord());
System.out.print("\u001B[1G");
AnkiCard card=new AnkiCard();
card.setQuestion(item.getWord());
String answer=dict.translate(item.getWord());
if(answer!=null && !"".equals(answer)){
card.setAnswer(answer);
result.add(card);
}else{
notFounded++;
}
}
Statistic.getInstance().setWordNotFoundCount(notFounded);
Statistic.getInstance().setCardTotalCount(result.size());
return result;
}
}
| Java |
package simulating;
public class Mapper {
}
| Java |
package simulating;
public class Seeded {
}
| Java |
package simulating;
public class Joiner {
}
| Java |
package simulating;
public class InitializationTsets {
}
| Java |
package inputGenerate;
public class inputGenerator {
}
| Java |
package driver;
import java.io.IOException;
import java.util.Date;
import java.util.Random;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.SequenceFile;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.SequenceFile.CompressionType;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.SequenceFileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import simulating.DataCenter;
import simulating.Process;
public class Traggle extends Configured implements Tool {
private int tasks = 1;
static public int numMaps = 2;
static public final int turns = 2;
static public double[] temperture = new double[turns];
static public double[] decrease = new double[turns];
static private Random randomGenerator = new Random(); // ��������
static private final Path TMP_DIR = new Path("myAnnelDir");
private static void initParameter() {
for (int i = 0; i < turns; i++) {
temperture[i] = DataCenter.coveringArrayNum
* randomGenerator.nextDouble();
decrease[i] = randomGenerator.nextDouble();
}
}
public static class Map extends
Mapper<LongWritable, LongWritable, Text, Text> {
int param[] = { 5, 5, 5, 5 ,5 ,5 };
protected void map(LongWritable key, LongWritable value, Context context)
throws java.io.IOException, InterruptedException {
if (DataCenter.degree < 0) {
DataCenter.init(param, 3);
initParameter();
}
String line = context.getConfiguration().get("paramAnnel")
.toString();
StringTokenizer itr = new StringTokenizer(line);
double T = Double.parseDouble(itr.nextToken());
double decrement = Double.parseDouble(itr.nextToken());
Process t = new Process(T, decrement);
t.process();
context.write(new Text("time"), new Text(t.time + ""));
context.write(new Text("length"), new Text(t.rsTable.length + ""));
String RTable = new String();
for (int i = 0; i < t.rsTable.length; i++) {
for (int j = 0; j < t.rsTable[i].length; j++) {
RTable += t.rsTable[i][j] + "\t";
}
RTable += "\r\n";
}
context.write(new Text("table"), new Text(RTable));
}
}
public static class Reduce extends Reducer<Text, Text, Text, Text> {
public void reduce(Text key, Iterable<Text> values, Context context)
throws IOException, InterruptedException {
context.write(new Text("T adn Decrease"), new Text(context
.getConfiguration().get("paramAnnel")));
context.write(new Text("100 times" + key), new Text());
if (key.equals(new Text("table"))) {
for (Text val : values) {
context.write(new Text(" "), val);
}
} else {
long sum = 0;
for (Text val : values) {
sum += Integer.parseInt(val.toString());
context.write(new Text(" "), val);
}
sum /= numMaps;
context.write(new Text(key + " avg:"), new Text(sum + ""));
}
}
}
public void configMyWork(Job job) {
job.setMapperClass(Map.class);
job.setReducerClass(Reduce.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.setInputFormatClass(SequenceFileInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
job.setNumReduceTasks(tasks);
}
public void initInput(Job job) throws IOException {
final FileSystem fs = FileSystem.get(job.getConfiguration());
try {
// generate an input file for each map task
for (int i = 0; i < numMaps; ++i) {
final Path file = new Path(new Path(TMP_DIR, "test-in"), "part"
+ i);
final LongWritable offset = new LongWritable(i);
final LongWritable size = new LongWritable(1);
final SequenceFile.Writer writer = SequenceFile.createWriter(
fs, job.getConfiguration(), file, LongWritable.class,
LongWritable.class, CompressionType.NONE);
try {
writer.append(offset, size);
} finally {
writer.close();
}
System.out.println("Wrote input for Map #" + i);
}
} finally {
}
}
@Override
public int run(String[] args) throws Exception {
// TODO Auto-generated method stub
long starttime=new Date().getTime();
for (int i = 0; i < turns; i++) {
for (int j = 0; j < turns; j++) {
Configuration conf = new Configuration();
conf.set("paramAnnel", temperture[i] + " " + decrease[j]);
Job job = new Job(conf, "myWork" + i + "_" + j);
job.setJarByClass(Traggle.class);
configMyWork(job);
FileInputFormat.setInputPaths(job, new Path(TMP_DIR, args[0]));
FileOutputFormat.setOutputPath(job, new Path(TMP_DIR, args[1]
+ "" + i + "_" + j));
initInput(job);
job.waitForCompletion(true);
}
}
long endtime=new Date().getTime();
System.out.println("all need time:"+(endtime-starttime));
return 0;
}
public static void main(String[] args) throws Exception {
args = new String[] { "test-in", "test-out" };
System.exit(ToolRunner.run(null, new Traggle(), args));
}
}
| Java |
/**
* MultiTouchVisualizerActivity.java
*
* (c) Luke Hutchison (luke.hutch@mit.edu)
*
* --
*
* Released under the MIT license (but please notify me if you use this code, so that I can give your project credit at
* http://code.google.com/p/android-multitouch-controller ).
*
* MIT license: http://www.opensource.org/licenses/MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
package org.metalev.multitouch.visualizer2;
import android.app.Activity;
import android.os.Bundle;
public class MultiTouchVisualizerActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setTitle(R.string.instructions);
setContentView(new MultiTouchVisualizerView(this));
}
} | Java |
/**
* MultiTouchVisualizerView.java
*
* (c) Luke Hutchison (luke.hutch@mit.edu)
*
* --
*
* Released under the MIT license (but please notify me if you use this code, so that I can give your project credit at
* http://code.google.com/p/android-multitouch-controller ).
*
* MIT license: http://www.opensource.org/licenses/MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
package org.metalev.multitouch.visualizer2;
import org.metalev.multitouch.controller.MultiTouchController;
import org.metalev.multitouch.controller.MultiTouchController.MultiTouchObjectCanvas;
import org.metalev.multitouch.controller.MultiTouchController.PointInfo;
import org.metalev.multitouch.controller.MultiTouchController.PositionAndScale;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.graphics.Paint.Align;
import android.graphics.Paint.Style;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
public class MultiTouchVisualizerView extends View implements MultiTouchObjectCanvas<Object> {
private MultiTouchController<Object> multiTouchController;
private PointInfo mCurrTouchPoint;
// --
private static final int[] TOUCH_COLORS = { Color.YELLOW, Color.GREEN, Color.CYAN, Color.MAGENTA, Color.YELLOW, Color.BLUE, Color.WHITE,
Color.GRAY, Color.LTGRAY, Color.DKGRAY };
private Paint mLinePaintSingleTouch = new Paint();
private Paint mLinePaintCoords = new Paint();
private Paint mLinePaintSnapped = new Paint();
private Paint mLinePaintSecondTouch = new Paint();
private Paint mLinePaintMultiTouch = new Paint();
private Paint mLinePaintCrossHairs = new Paint();
private Paint mPointLabelPaint = new Paint();
private Paint mTouchTheScreenLabelPaint = new Paint();
private Paint mPointLabelBg = new Paint();
private Paint mAngLabelPaint = new Paint();
private Paint mAngLabelBg = new Paint();
private int[] mTouchPointColors = new int[MultiTouchController.MAX_TOUCH_POINTS];
// ------------------------------------------------------------------------------------
public MultiTouchVisualizerView(Context context) {
this(context, null);
}
public MultiTouchVisualizerView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public MultiTouchVisualizerView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
multiTouchController = new MultiTouchController<Object>(this);
mCurrTouchPoint = new PointInfo();
mLinePaintSingleTouch.setColor(TOUCH_COLORS[0]);
mLinePaintSingleTouch.setStrokeWidth(5);
mLinePaintSingleTouch.setStyle(Style.STROKE);
mLinePaintSingleTouch.setAntiAlias(true);
mLinePaintCoords.setColor(Color.RED);
mLinePaintCoords.setStrokeWidth(5);
mLinePaintCoords.setStyle(Style.STROKE);
mLinePaintCoords.setAntiAlias(true);
mLinePaintSnapped.setColor(Color.BLUE);
mLinePaintSnapped.setAlpha(128);
mLinePaintSnapped.setStyle(Style.STROKE);
mLinePaintSnapped.setStrokeWidth(40);
mLinePaintCoords.setAntiAlias(false);
mLinePaintSecondTouch.setColor(TOUCH_COLORS[1]);
mLinePaintSecondTouch.setStrokeWidth(5);
mLinePaintSecondTouch.setStyle(Style.STROKE);
mLinePaintSecondTouch.setAntiAlias(true);
mLinePaintMultiTouch.setStrokeWidth(5);
mLinePaintMultiTouch.setStyle(Style.STROKE);
mLinePaintMultiTouch.setAntiAlias(true);
mLinePaintCrossHairs.setColor(Color.BLUE);
mLinePaintCrossHairs.setStrokeWidth(5);
mLinePaintCrossHairs.setStyle(Style.STROKE);
mLinePaintCrossHairs.setAntiAlias(true);
mPointLabelPaint.setTextSize(82);
mPointLabelPaint.setTypeface(Typeface.DEFAULT_BOLD);
mPointLabelPaint.setAntiAlias(true);
mTouchTheScreenLabelPaint.setColor(Color.GRAY);
mTouchTheScreenLabelPaint.setTextSize(24);
mTouchTheScreenLabelPaint.setTypeface(Typeface.DEFAULT_BOLD);
mTouchTheScreenLabelPaint.setAntiAlias(true);
mPointLabelBg.set(mPointLabelPaint);
mPointLabelBg.setColor(Color.BLACK);
mPointLabelBg.setAlpha(180);
mPointLabelBg.setStyle(Style.STROKE);
mPointLabelBg.setStrokeWidth(15);
mAngLabelPaint.setTextSize(32);
mAngLabelPaint.setTypeface(Typeface.SANS_SERIF);
mAngLabelPaint.setColor(mLinePaintCrossHairs.getColor());
mAngLabelPaint.setTextAlign(Align.CENTER);
mAngLabelPaint.setAntiAlias(true);
mAngLabelBg.set(mAngLabelPaint);
mAngLabelBg.setColor(Color.BLACK);
mAngLabelBg.setAlpha(180);
mAngLabelBg.setStyle(Style.STROKE);
mAngLabelBg.setStrokeWidth(15);
setBackgroundColor(Color.BLACK);
for (int i = 0; i < MultiTouchController.MAX_TOUCH_POINTS; i++)
mTouchPointColors[i] = i < TOUCH_COLORS.length ? TOUCH_COLORS[i] : (int) (Math.random() * 0xffffff) + 0xff000000;
}
@Override
public boolean onTouchEvent(MotionEvent event) {
// Pass the event on to the controller
return multiTouchController.onTouchEvent(event);
}
public Object getDraggableObjectAtPoint(PointInfo pt) {
// IMPORTANT: to start a multitouch drag operation, this routine must return non-null
return this;
}
public void getPositionAndScale(Object obj, PositionAndScale objPosAndScaleOut) {
// We aren't dragging any objects, so this doesn't do anything in this app
}
public void selectObject(Object obj, PointInfo touchPoint) {
// We aren't dragging any objects in this particular app, but this is called when the point goes up (obj == null) or down (obj != null),
// save the touch point info
touchPointChanged(touchPoint);
}
public boolean setPositionAndScale(Object obj, PositionAndScale newObjPosAndScale, PointInfo touchPoint) {
// Called during a drag or stretch operation, update the touch point info
touchPointChanged(touchPoint);
return true;
}
/**
* Called when the touch point info changes, causes a redraw.
*
* @param touchPoint
*/
private void touchPointChanged(PointInfo touchPoint) {
// Take a snapshot of touch point info, the touch point is volatile
mCurrTouchPoint.set(touchPoint);
invalidate();
}
private void paintText(Canvas canvas, String msg, float vPos) {
Rect bounds = new Rect();
int msgLen = msg.length();
mTouchTheScreenLabelPaint.getTextBounds(msg, 0, msgLen, bounds);
canvas.drawText(msg, (canvas.getWidth() - bounds.width()) * .5f, vPos, mTouchTheScreenLabelPaint);
}
private static final String[] infoLines = { "Touch the screen", "with one or more", "fingers to test", "multitouch", "characteristics" };
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (mCurrTouchPoint.isDown()) {
int numPoints = mCurrTouchPoint.getNumTouchPoints();
float[] xs = mCurrTouchPoint.getXs();
float[] ys = mCurrTouchPoint.getYs();
float[] pressures = mCurrTouchPoint.getPressures();
int[] pointerIds = mCurrTouchPoint.getPointerIds();
float x = mCurrTouchPoint.getX(), y = mCurrTouchPoint.getY();
float wd = getWidth(), ht = getHeight();
if (numPoints == 1) {
// Draw ordinate lines for single touch point
canvas.drawLine(0, y, wd, y, mLinePaintCoords);
canvas.drawLine(x, 0, x, ht, mLinePaintCoords);
} else if (numPoints == 2) {
float dx2 = mCurrTouchPoint.getMultiTouchWidth() / 2;
float dy2 = mCurrTouchPoint.getMultiTouchHeight() / 2;
// Horiz/vert ordinate lines
if (dx2 < 0.85f) {
// Snapped (for some reason, it's not precise on the Nexus One due to event noise)
canvas.drawLine(x, 0, x, ht, mLinePaintSnapped);
} else {
canvas.drawLine(x + dx2, 0, x + dx2, ht, mLinePaintCoords);
canvas.drawLine(x - dx2, 0, x - dx2, ht, mLinePaintCoords);
}
if (dy2 < 0.85f) {
// Snapped
canvas.drawLine(0, y, wd, y, mLinePaintSnapped);
} else {
canvas.drawLine(0, y + dy2, wd, y + dy2, mLinePaintCoords);
canvas.drawLine(0, y - dy2, wd, y - dy2, mLinePaintCoords);
}
// Diag lines
canvas.drawLine(x + dx2, y + dy2, x - dx2, y - dy2, mLinePaintCrossHairs);
canvas.drawLine(x + dx2, y - dy2, x - dx2, y + dy2, mLinePaintCrossHairs);
// Crosshairs
canvas.drawLine(0, y, wd, y, mLinePaintCrossHairs);
canvas.drawLine(x, 0, x, ht, mLinePaintCrossHairs);
// Circle
canvas.drawCircle(x, y, mCurrTouchPoint.getMultiTouchDiameter() / 2, mLinePaintCrossHairs);
}
// Show touch circles
for (int i = 0; i < numPoints; i++) {
mLinePaintMultiTouch.setColor(mTouchPointColors[i]);
float r = 70 + pressures[i] * 120;
canvas.drawCircle(xs[i], ys[i], r, mLinePaintMultiTouch);
}
// Label pinch distance
if (numPoints == 2) {
float ang = mCurrTouchPoint.getMultiTouchAngle() * 180.0f / (float) Math.PI;
// Keep text rightway up
if (ang < -91.0f)
ang += 180.0f;
else if (ang > 91.0f)
ang -= 180.0f;
String angStr = "Pinch dist: " + Math.round(mCurrTouchPoint.getMultiTouchDiameter());
canvas.save();
canvas.translate(x, y);
canvas.rotate(ang);
canvas.drawText(angStr, 0, -10, mAngLabelBg);
canvas.drawText(angStr, 0, -10, mAngLabelPaint);
canvas.restore();
}
// Log touch point indices
if (MultiTouchController.DEBUG) {
StringBuilder buf = new StringBuilder();
for (int i = 0; i < numPoints; i++)
buf.append(" " + i + "->" + pointerIds[i]);
Log.i("MultiTouchVisualizer", buf.toString());
}
// Label touch points on top of everything else
for (int idx = 0; idx < numPoints; idx++) {
int id = pointerIds[idx];
mPointLabelPaint.setColor(mTouchPointColors[idx]);
float r = 70 + pressures[idx] * 120, d = r * .71f;
String label = (idx + 1) + (idx == id ? "" : "(id:" + (id + 1) + ")");
canvas.drawText(label, xs[idx] + d, ys[idx] - d, mPointLabelBg);
canvas.drawText(label, xs[idx] + d, ys[idx] - d, mPointLabelPaint);
}
} else {
float spacing = mTouchTheScreenLabelPaint.getFontSpacing();
float totHeight = spacing * infoLines.length;
for (int i = 0; i < infoLines.length; i++)
paintText(canvas, infoLines[i], (canvas.getHeight() - totHeight) * .5f + i * spacing);
}
}
}
| Java |
/**
* PhotoSorterView.java
*
* (c) Luke Hutchison (luke.hutch@mit.edu)
*
* TODO: Add OpenGL acceleration.
*
* --
*
* Released under the MIT license (but please notify me if you use this code, so that I can give your project credit at
* http://code.google.com/p/android-multitouch-controller ).
*
* MIT license: http://www.opensource.org/licenses/MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
package org.metalev.multitouch.photosortr;
import java.util.ArrayList;
import org.metalev.multitouch.controller.MultiTouchController;
import org.metalev.multitouch.controller.MultiTouchController.MultiTouchObjectCanvas;
import org.metalev.multitouch.controller.MultiTouchController.PointInfo;
import org.metalev.multitouch.controller.MultiTouchController.PositionAndScale;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.View;
public class PhotoSortrView extends View implements MultiTouchObjectCanvas<PhotoSortrView.Img> {
private static final int[] IMAGES = { R.drawable.m74hubble, R.drawable.catarina, R.drawable.tahiti, R.drawable.sunset, R.drawable.lake };
private ArrayList<Img> mImages = new ArrayList<Img>();
// --
private MultiTouchController<Img> multiTouchController = new MultiTouchController<Img>(this);
// --
private PointInfo currTouchPoint = new PointInfo();
private boolean mShowDebugInfo = true;
private static final int UI_MODE_ROTATE = 1, UI_MODE_ANISOTROPIC_SCALE = 2;
private int mUIMode = UI_MODE_ROTATE;
// --
private Paint mLinePaintTouchPointCircle = new Paint();
// ---------------------------------------------------------------------------------------------------
public PhotoSortrView(Context context) {
this(context, null);
}
public PhotoSortrView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public PhotoSortrView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init(context);
}
private void init(Context context) {
Resources res = context.getResources();
for (int i = 0; i < IMAGES.length; i++)
mImages.add(new Img(IMAGES[i], res));
mLinePaintTouchPointCircle.setColor(Color.YELLOW);
mLinePaintTouchPointCircle.setStrokeWidth(5);
mLinePaintTouchPointCircle.setStyle(Style.STROKE);
mLinePaintTouchPointCircle.setAntiAlias(true);
setBackgroundColor(Color.BLACK);
}
/** Called by activity's onResume() method to load the images */
public void loadImages(Context context) {
Resources res = context.getResources();
int n = mImages.size();
for (int i = 0; i < n; i++)
mImages.get(i).load(res);
}
/** Called by activity's onPause() method to free memory used for loading the images */
public void unloadImages() {
int n = mImages.size();
for (int i = 0; i < n; i++)
mImages.get(i).unload();
}
// ---------------------------------------------------------------------------------------------------
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
int n = mImages.size();
for (int i = 0; i < n; i++)
mImages.get(i).draw(canvas);
if (mShowDebugInfo)
drawMultitouchDebugMarks(canvas);
}
// ---------------------------------------------------------------------------------------------------
public void trackballClicked() {
mUIMode = (mUIMode + 1) % 3;
invalidate();
}
private void drawMultitouchDebugMarks(Canvas canvas) {
if (currTouchPoint.isDown()) {
float[] xs = currTouchPoint.getXs();
float[] ys = currTouchPoint.getYs();
float[] pressures = currTouchPoint.getPressures();
int numPoints = Math.min(currTouchPoint.getNumTouchPoints(), 2);
for (int i = 0; i < numPoints; i++)
canvas.drawCircle(xs[i], ys[i], 50 + pressures[i] * 80, mLinePaintTouchPointCircle);
if (numPoints == 2)
canvas.drawLine(xs[0], ys[0], xs[1], ys[1], mLinePaintTouchPointCircle);
}
}
// ---------------------------------------------------------------------------------------------------
/** Pass touch events to the MT controller */
@Override
public boolean onTouchEvent(MotionEvent event) {
return multiTouchController.onTouchEvent(event);
}
/** Get the image that is under the single-touch point, or return null (canceling the drag op) if none */
public Img getDraggableObjectAtPoint(PointInfo pt) {
float x = pt.getX(), y = pt.getY();
int n = mImages.size();
for (int i = n - 1; i >= 0; i--) {
Img im = mImages.get(i);
if (im.containsPoint(x, y))
return im;
}
return null;
}
/**
* Select an object for dragging. Called whenever an object is found to be under the point (non-null is returned by getDraggableObjectAtPoint())
* and a drag operation is starting. Called with null when drag op ends.
*/
public void selectObject(Img img, PointInfo touchPoint) {
currTouchPoint.set(touchPoint);
if (img != null) {
// Move image to the top of the stack when selected
mImages.remove(img);
mImages.add(img);
} else {
// Called with img == null when drag stops.
}
invalidate();
}
/** Get the current position and scale of the selected image. Called whenever a drag starts or is reset. */
public void getPositionAndScale(Img img, PositionAndScale objPosAndScaleOut) {
// FIXME affine-izem (and fix the fact that the anisotropic_scale part requires averaging the two scale factors)
objPosAndScaleOut.set(img.getCenterX(), img.getCenterY(), (mUIMode & UI_MODE_ANISOTROPIC_SCALE) == 0,
(img.getScaleX() + img.getScaleY()) / 2, (mUIMode & UI_MODE_ANISOTROPIC_SCALE) != 0, img.getScaleX(), img.getScaleY(),
(mUIMode & UI_MODE_ROTATE) != 0, img.getAngle());
}
/** Set the position and scale of the dragged/stretched image. */
public boolean setPositionAndScale(Img img, PositionAndScale newImgPosAndScale, PointInfo touchPoint) {
currTouchPoint.set(touchPoint);
boolean ok = img.setPos(newImgPosAndScale);
if (ok)
invalidate();
return ok;
}
// ----------------------------------------------------------------------------------------------
class Img {
private int resId;
private Drawable drawable;
private boolean firstLoad;
private int width, height, displayWidth, displayHeight;
private float centerX, centerY, scaleX, scaleY, angle;
private float minX, maxX, minY, maxY;
private static final float SCREEN_MARGIN = 100;
public Img(int resId, Resources res) {
this.resId = resId;
this.firstLoad = true;
getMetrics(res);
}
private void getMetrics(Resources res) {
DisplayMetrics metrics = res.getDisplayMetrics();
// The DisplayMetrics don't seem to always be updated on screen rotate, so we hard code a portrait
// screen orientation for the non-rotated screen here...
// this.displayWidth = metrics.widthPixels;
// this.displayHeight = metrics.heightPixels;
this.displayWidth = res.getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE ? Math.max(metrics.widthPixels,
metrics.heightPixels) : Math.min(metrics.widthPixels, metrics.heightPixels);
this.displayHeight = res.getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE ? Math.min(metrics.widthPixels,
metrics.heightPixels) : Math.max(metrics.widthPixels, metrics.heightPixels);
}
/** Called by activity's onResume() method to load the images */
public void load(Resources res) {
getMetrics(res);
this.drawable = res.getDrawable(resId);
this.width = drawable.getIntrinsicWidth();
this.height = drawable.getIntrinsicHeight();
float cx, cy, sx, sy;
if (firstLoad) {
cx = SCREEN_MARGIN + (float) (Math.random() * (displayWidth - 2 * SCREEN_MARGIN));
cy = SCREEN_MARGIN + (float) (Math.random() * (displayHeight - 2 * SCREEN_MARGIN));
float sc = (float) (Math.max(displayWidth, displayHeight) / (float) Math.max(width, height) * Math.random() * 0.3 + 0.2);
sx = sy = sc;
firstLoad = false;
} else {
// Reuse position and scale information if it is available
// FIXME this doesn't actually work because the whole activity is torn down and re-created on rotate
cx = this.centerX;
cy = this.centerY;
sx = this.scaleX;
sy = this.scaleY;
// Make sure the image is not off the screen after a screen rotation
if (this.maxX < SCREEN_MARGIN)
cx = SCREEN_MARGIN;
else if (this.minX > displayWidth - SCREEN_MARGIN)
cx = displayWidth - SCREEN_MARGIN;
if (this.maxY > SCREEN_MARGIN)
cy = SCREEN_MARGIN;
else if (this.minY > displayHeight - SCREEN_MARGIN)
cy = displayHeight - SCREEN_MARGIN;
}
setPos(cx, cy, sx, sy, 0.0f);
}
/** Called by activity's onPause() method to free memory used for loading the images */
public void unload() {
this.drawable = null;
}
/** Set the position and scale of an image in screen coordinates */
public boolean setPos(PositionAndScale newImgPosAndScale) {
return setPos(newImgPosAndScale.getXOff(), newImgPosAndScale.getYOff(), (mUIMode & UI_MODE_ANISOTROPIC_SCALE) != 0 ? newImgPosAndScale
.getScaleX() : newImgPosAndScale.getScale(), (mUIMode & UI_MODE_ANISOTROPIC_SCALE) != 0 ? newImgPosAndScale.getScaleY()
: newImgPosAndScale.getScale(), newImgPosAndScale.getAngle());
// FIXME: anisotropic scaling jumps when axis-snapping
// FIXME: affine-ize
// return setPos(newImgPosAndScale.getXOff(), newImgPosAndScale.getYOff(), newImgPosAndScale.getScaleAnisotropicX(),
// newImgPosAndScale.getScaleAnisotropicY(), 0.0f);
}
/** Set the position and scale of an image in screen coordinates */
private boolean setPos(float centerX, float centerY, float scaleX, float scaleY, float angle) {
float ws = (width / 2) * scaleX, hs = (height / 2) * scaleY;
float newMinX = centerX - ws, newMinY = centerY - hs, newMaxX = centerX + ws, newMaxY = centerY + hs;
if (newMinX > displayWidth - SCREEN_MARGIN || newMaxX < SCREEN_MARGIN || newMinY > displayHeight - SCREEN_MARGIN
|| newMaxY < SCREEN_MARGIN)
return false;
this.centerX = centerX;
this.centerY = centerY;
this.scaleX = scaleX;
this.scaleY = scaleY;
this.angle = angle;
this.minX = newMinX;
this.minY = newMinY;
this.maxX = newMaxX;
this.maxY = newMaxY;
return true;
}
/** Return whether or not the given screen coords are inside this image */
public boolean containsPoint(float scrnX, float scrnY) {
// FIXME: need to correctly account for image rotation
return (scrnX >= minX && scrnX <= maxX && scrnY >= minY && scrnY <= maxY);
}
public void draw(Canvas canvas) {
canvas.save();
float dx = (maxX + minX) / 2;
float dy = (maxY + minY) / 2;
drawable.setBounds((int) minX, (int) minY, (int) maxX, (int) maxY);
canvas.translate(dx, dy);
canvas.rotate(angle * 180.0f / (float) Math.PI);
canvas.translate(-dx, -dy);
drawable.draw(canvas);
canvas.restore();
}
public Drawable getDrawable() {
return drawable;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
public float getCenterX() {
return centerX;
}
public float getCenterY() {
return centerY;
}
public float getScaleX() {
return scaleX;
}
public float getScaleY() {
return scaleY;
}
public float getAngle() {
return angle;
}
// FIXME: these need to be updated for rotation
public float getMinX() {
return minX;
}
public float getMaxX() {
return maxX;
}
public float getMinY() {
return minY;
}
public float getMaxY() {
return maxY;
}
}
}
| Java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.