code stringlengths 3 1.18M | language stringclasses 1 value |
|---|---|
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 {
OutputStream os;
InputStream is;
byte[] buffer = new byte[Channel.CHANNEL_BUFFER_SIZE];
Channel c;
StreamForwarder sibling;
Socket s;
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;
}
@Override
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) {
}
try {
if (s != null)
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 String getExitSignal() {
synchronized (this) {
return exit_signal;
}
}
public Integer getExitStatus() {
synchronized (this) {
return exit_status;
}
}
public String getReasonClosed() {
synchronized (reasonClosedLock) {
return reasonClosed;
}
}
public ChannelInputStream getStderrStream() {
return stderrStream;
}
public ChannelOutputStream getStdinStream() {
return stdinStream;
}
public ChannelInputStream getStdoutStream() {
return stdoutStream;
}
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;
import android.util.Log;
/**
* DynamicAcceptThread.
*
* @author Kenny Root
* @version $Id$
*/
public class DynamicAcceptThread extends Thread implements IChannelWorkerThread {
class DynamicAcceptRunnable implements Runnable {
private static final int idleTimeout = 60000; // 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");
}
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 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, null, 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();
}
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;
}
@Override
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);
} catch (Error e) {
// Force to GC here
System.gc();
} finally {
if (auth != null)
auth.endSession();
thread_num--;
}
}
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 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 volatile int thread_num = 0;
private ChannelManager cm;
private final static int MAX_THREAD_COUNT = 2;
private ServerSocket ss;
public DynamicAcceptThread(ChannelManager cm, InetSocketAddress localAddress)
throws IOException {
this.cm = cm;
ss = new ServerSocket();
ss.bind(localAddress);
}
public DynamicAcceptThread(ChannelManager cm, int local_port)
throws IOException {
this.cm = cm;
setName("DynamicAcceptThread");
ss = new ServerSocket(local_port);
}
@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();
thread_num++;
while (thread_num > MAX_THREAD_COUNT) {
Log.d("SOCKSProxy", "Max thread number exceeded");
System.gc();
try {
Thread.sleep(2000);
} catch (InterruptedException ignore) {
// Nothing
}
}
}
}
/*
* (non-Javadoc)
*
* @see com.trilead.ssh2.channel.IChannelWorkerThread#stopWorking()
*/
@Override
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");
}
/**
* @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) {
}
}
}
/**
* @return whether the agent is locked
*/
private boolean failWhenLocked() throws IOException {
if (authAgent.isAgentLocked()) {
os.write(SSH_AGENT_FAILURE);
return true;
} else
return false;
}
/**
* @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) {
}
}
}
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 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 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) {
}
}
}
/**
* @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) {
}
}
}
@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) {
}
}
}
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 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());
}
@Override
public void stopWorking() {
try {
/* This will lead to an IOException in the is.read() call */
is.close();
} catch (IOException e) {
}
}
}
| 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;
}
@Override
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, null, 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 int addChannel(Channel c) {
synchronized (channels) {
channels.addElement(c);
return nextLocalChannel++;
}
}
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 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));
}
}
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;
}
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;
}
@Override
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));
}
}
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 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 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 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();
}
}
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 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 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 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 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 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 msgGlobalFailure() throws IOException {
synchronized (channels) {
globalFailedCounter++;
channels.notifyAll();
}
if (log.isEnabled())
log.log(80, "Got SSH_MSG_REQUEST_FAILURE");
}
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 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 registerThread(IChannelWorkerThread thr) throws IOException {
synchronized (listenerThreads) {
if (listenerThreadsAllowed == false)
throw new IOException("Too late, this connection is closed.");
listenerThreads.addElement(thr);
}
}
public void registerX11Cookie(String hexFakeCookie, X11ServerData data) {
synchronized (x11_magic_cookies) {
x11_magic_cookies.put(hexFakeCookie, data);
}
}
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;
}
}
}
}
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 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 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 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 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 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 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 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 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 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 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 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 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) {
}
}
}
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.");
}
}
/**
* 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) {
}
}
}
}
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 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 + ")");
}
}
}
}
| 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 |
/* proxydroid - Global / Individual Proxy App for Android
* Copyright (C) 2011 K's Maze <kafkasmaze@gmail.com>
*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*
*/
package com.ksmaze.android.preference;
import android.app.AlertDialog.Builder;
import android.content.Context;
import android.content.DialogInterface;
import android.preference.ListPreference;
import android.preference.Preference;
import android.util.AttributeSet;
/**
* A {@link Preference} that displays a list of entries as
* a dialog and allows multiple selections
* <p>
* This preference will store a string into the SharedPreferences. This string will be the values selected
* from the {@link #setEntryValues(CharSequence[])} array.
* </p>
*/
public class ListPreferenceMultiSelect extends ListPreference {
//Need to make sure the SEPARATOR is unique and weird enough that it doesn't match one of the entries.
//Not using any fancy symbols because this is interpreted as a regex for splitting strings.
private static final String SEPARATOR = " , ";
public static String[] parseStoredValue(CharSequence val) {
if (val == null)
return null;
if ( "".equals(val) )
return null;
else
return ((String)val).split(SEPARATOR);
}
private boolean[] mClickedDialogEntryIndices;
public ListPreferenceMultiSelect(Context context) {
this(context, null);
}
public ListPreferenceMultiSelect(Context context, AttributeSet attrs) {
super(context, attrs);
mClickedDialogEntryIndices = new boolean[getEntries().length];
}
@Override
protected void onDialogClosed(boolean positiveResult) {
// super.onDialogClosed(positiveResult);
CharSequence[] entryValues = getEntryValues();
if (positiveResult && entryValues != null) {
StringBuffer value = new StringBuffer();
for ( int i=0; i<entryValues.length; i++ ) {
if ( mClickedDialogEntryIndices[i] ) {
value.append(entryValues[i]).append(SEPARATOR);
}
}
if (callChangeListener(value)) {
String val = value.toString();
if ( val.length() > 0 )
val = val.substring(0, val.length()-SEPARATOR.length());
setValue(val);
}
}
}
@Override
protected void onPrepareDialogBuilder(Builder builder) {
CharSequence[] entries = getEntries();
CharSequence[] entryValues = getEntryValues();
if (entries == null || entryValues == null || entries.length != entryValues.length ) {
throw new IllegalStateException(
"ListPreference requires an entries array and an entryValues array which are both the same length");
}
restoreCheckedEntries();
builder.setMultiChoiceItems(entries, mClickedDialogEntryIndices,
new DialogInterface.OnMultiChoiceClickListener() {
@Override
public void onClick(DialogInterface dialog, int which, boolean val) {
mClickedDialogEntryIndices[which] = val;
}
});
}
private void restoreCheckedEntries() {
CharSequence[] entryValues = getEntryValues();
String[] vals = parseStoredValue(getValue());
if ( vals != null ) {
for ( int j=0; j<vals.length; j++ ) {
String val = vals[j].trim();
for ( int i=0; i<entryValues.length; i++ ) {
CharSequence entry = entryValues[i];
if ( entry.equals(val) ) {
mClickedDialogEntryIndices[i] = true;
break;
}
}
}
}
}
@Override
public void setEntries(CharSequence[] entries) {
super.setEntries(entries);
mClickedDialogEntryIndices = new boolean[entries.length];
}
}
| 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.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
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;
private boolean nomoreinput = false;
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 int available() throws IOException { return inf.finished() ? 0 :
* 1; }
*/
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;
}
@Override
public void close() throws IOException {
in.close();
}
public int getFlushMode() {
return (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;
}
@Override
public int read() throws IOException {
if (read(buf1, 0, 1) == -1)
return (-1);
return (buf1[0] & 0xFF);
}
@Override
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 void setFlushMode(int flush) {
this.flush = flush;
}
@Override
public long skip(long n) throws IOException {
int len = 512;
if (n < len)
len = (int) n;
byte[] tmp = new byte[len];
return read(tmp);
}
}
| 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.IOException;
import java.io.OutputStream;
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;
}
@Override
public void close() throws IOException {
try {
try {
finish();
} catch (IOException ignored) {
}
} finally {
end();
out.close();
out = null;
}
}
public void end() {
if (z == null)
return;
if (compress) {
z.deflateEnd();
} else {
z.inflateEnd();
}
z.free();
z = null;
}
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();
}
@Override
public void flush() throws IOException {
out.flush();
}
public int getFlushMode() {
return (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 setFlushMode(int flush) {
this.flush = flush;
}
@Override
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);
}
@Override
public void write(int b) throws IOException {
buf1[0] = (byte) b;
write(buf1, 0, 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 public class JZlib {
private static final String version = "1.0.2";
// 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;
public static String version() {
return version;
}
}
| 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 free(ZStream z) {
// ZFREE(z, c);
}
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] + (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;
}
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;
}
// 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 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);
}
}
}
}
| 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
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;
}
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] = (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;
}
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 };
// 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;
}
// 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)]);
}
// 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));
}
}
short[] dyn_tree; // the dynamic tree
int max_code; // largest code with non zero frequency
StaticTree stat_desc; // the corresponding static tree
// 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);
}
// 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])
* tree[m * 2];
tree[m * 2 + 1] = (short) bits;
}
n--;
}
}
}
}
| 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 free(ZStream z) {
reset(z, null);
window = null;
hufts = null;
// ZFREE(z, s);
}
// 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 = ((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;
}
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 = (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 = (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 = (q < read ? read - q - 1 : end - q);
}
if (m == 0) {
write = q;
r = inflate_flush(z, r);
q = write;
m = (q < read ? read - q - 1 : end - q);
if (q == end && read != 0) {
q = 0;
m = (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 = (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 = (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 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);
}
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;
}
}
| 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 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 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 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;
}
}
public void free() {
next_in = null;
next_out = null;
msg = null;
_adler = null;
}
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 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 inflateSetDictionary(byte[] dictionary, int dictLength) {
if (istate == null)
return Z_STREAM_ERROR;
return istate.inflateSetDictionary(this, dictionary, dictLength);
}
public int inflateSync() {
if (istate == null)
return Z_STREAM_ERROR;
return istate.inflateSync(this);
}
// 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;
}
}
| 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
static private byte[] mark = { (byte) 0, (byte) 0, (byte) 0xff, (byte) 0xff };
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 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 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 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;
}
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 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 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 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;
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]));
}
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
// Window position at the beginning of the current output block. Gets
// negative when the window is moved backwards.
// 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;
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;
// 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.
// 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;
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;
// 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 last_lit; // running index in l_buf
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
}
// 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;
}
// 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();
}
}
// 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
}
// 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 += 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.
}
// 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;
}
// 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 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];
}
// 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);
}
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;
}
// 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;
}
// 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 = (strstart - max_start);
strstart = 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;
}
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 deflateInit(ZStream strm, int level) {
return deflateInit(strm, level, MAX_WBITS);
}
int deflateInit(ZStream strm, int level, int bits) {
return deflateInit2(strm, level, Z_DEFLATED, bits, DEF_MEM_LEVEL,
Z_DEFAULT_STRATEGY);
}
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 = 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 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 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 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;
}
// 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);
}
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();
}
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;
}
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;
}
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 - (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;
}
// 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;
}
final void put_byte(byte c) {
pending_buf[pending++] = c;
}
// 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_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 */));
}
// 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;
}
}
}
// 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
}
void send_bits(int value, int length) {
int len = length;
if (bi_valid > 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;
}
}
final void send_code(int c, short[] tree) {
int c2 = c * 2;
send_bits((tree[c2] & 0xffff), (tree[c2 + 1] & 0xffff));
}
// 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;
}
}
}
// 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);
}
// 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();
}
}
| 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;
// 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;
/**
* 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;
}
/**
* 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);
}
/**
* 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);
}
/*
* private static final void debug(String s){ if(DEBUG) System.out.print(s);
* } private static final boolean DEBUG = false;
*/
/**
* 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);
}
/**
* 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.
*/
@Override
public InetAddress getInetAddress() throws UnknownHostException {
if (ip != null)
return ip;
return (ip = InetAddress.getByName(host));
}
/**
* 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.
*/
@Override
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.
*/
@Override
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) {
}
}
}
/**
* Returns string representation of the message.
*/
@Override
public String toString() {
String s = "Socks5Message:" + "\n" + "VN " + version + "\n" + "CMD "
+ command + "\n" + "ATYP " + addrType + "\n" + "ADDR " + host
+ "\n" + "PORT " + port + "\n";
return s;
}
/**
* Writes the message to the stream.
*
* @param out
* Output stream to which message should be written.
*/
@Override
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);
}
}
| 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;
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;
// Class methods
static InetAddress bytes2IP(byte[] addr) {
String s = bytes2IPV4(addr, 0);
try {
return InetAddress.getByName(s);
} catch (UnknownHostException uh_ex) {
return null;
}
}
// Constants
/**
* 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);
}
/**
* 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;
}
}
@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);
}
}
| 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();
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 instance methods
// ========================
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(Class) Methods
// ==============================
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;
/**
* 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;
}
/**
* 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);
}
// Protected Methods
// =================
/**
* 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 default proxy.
*
* @param p
* Proxy to use as default proxy.
*/
public static void setDefaultProxy(Proxy p) {
defaultProxy = p;
}
/**
* 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 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);
}
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;
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;
}
Proxy(Proxy chainProxy, InetAddress proxyIP, int proxyPort) {
this.chainProxy = chainProxy;
this.proxyIP = proxyIP;
this.proxyPort = proxyPort;
}
// Private methods
// ===============
// Constants
// Constructors
// ====================
Proxy(String proxyHost, int proxyPort) throws UnknownHostException {
this.proxyHost = proxyHost;
this.proxyIP = InetAddress.getByName(proxyHost);
this.proxyPort = proxyPort;
}
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 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 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 abstract Proxy copy();
protected void endSession() {
try {
if (proxySocket != null)
proxySocket.close();
proxySocket = null;
} catch (IOException io_ex) {
}
}
/**
* 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;
}
protected abstract ProxyMessage formMessage(InputStream in)
throws SocksException, IOException;
protected abstract ProxyMessage formMessage(int cmd, InetAddress ip,
int port);
protected abstract ProxyMessage formMessage(int cmd, String host, int port)
throws UnknownHostException;
/**
* Get the ip address of the proxy server host.
*
* @return Proxy InetAddress.
*/
public InetAddress getInetAddress() {
return proxyIP;
}
/**
* Get the port on which proxy server is running.
*
* @return Proxy port.
*/
public int getPort() {
return proxyPort;
}
/**
* Reads the reply from the SOCKS server
*/
protected ProxyMessage readMsg() throws SocksException, IOException {
return formMessage(in);
}
/**
* Sends the request to SOCKS server
*/
protected void sendMsg(ProxyMessage msg) throws SocksException, IOException {
msg.write(out);
}
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);
}
}
/**
* Get string representation of this proxy.
*
* @returns string in the form:proxyHost:proxyPort \t Version versionNumber
*/
@Override
public String toString() {
return ("" + proxyIP.getHostName() + ":" + proxyPort + "\tVersion " + version);
}
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");
}
}
| Java |
package net.sourceforge.jsocks;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
/**
* 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 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();
}
/**
* 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();
}
/**
* Accepts the incoming connection.
*/
@Override
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.
*/
@Override
public void close() throws IOException {
super.close();
if (proxy != null)
proxy.endSession();
proxy = null;
}
private void doDirect() {
doing_direct = true;
localPort = super.getLocalPort();
localIP = super.getInetAddress();
localHost = localIP.getHostName();
}
/**
* 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.
*/
@Override
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.
*/
@Override
public int getLocalPort() {
return localPort;
}
// Private Methods
// ////////////////
/**
* Set Timeout.
*
* @param timeout
* Amount of time in milliseconds, accept should wait for
* incoming connection before failing with exception. Zero
* timeout implies infinity.
*/
@Override
public void setSoTimeout(int timeout) throws SocketException {
super.setSoTimeout(timeout);
if (!doing_direct)
proxy.proxySocket.setSoTimeout(timeout);
}
}
| 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 {
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;
}
/** 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() {
}
ProxyMessage(int command, InetAddress ip, int port) {
this.command = command;
this.ip = ip;
this.port = port;
}
/**
* 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;
}
/**
* 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;
// Package methods
// ////////////////
/**
* Get string representaion of this message.
*
* @return string representation of this message.
*/
@Override
public String toString() {
return "Proxy Message:\n" + "Version:" + version + "\n" + "Command:"
+ command + "\n" + "IP: " + ip + "\n" + "Port: " + port
+ "\n" + "User: " + user + "\n";
}
/**
* 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;
}
| 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 };
/**
* 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;
}
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;
}
/**
* Allways returns true.
*/
@Override
public boolean checkRequest(java.net.DatagramPacket dp, boolean out) {
return true;
}
/**
* Allways returns true.
*/
@Override
public boolean checkRequest(ProxyMessage msg) {
return true;
}
/**
* Does nothing.
*/
@Override
public void endSession() {
}
/**
* Get input stream.
*
* @return Input stream speciefied in the constructor.
*/
@Override
public InputStream getInputStream() {
return in;
}
/**
* Get output stream.
*
* @return Output stream speciefied in the constructor.
*/
@Override
public OutputStream getOutputStream() {
return out;
}
/**
* Allways returns null.
*
* @return null
*/
@Override
public UDPEncapsulation getUdpEncapsulation() {
return null;
}
/**
* Grants access to everyone.Removes authentication related bytes from the
* stream, when a SOCKS5 connection is being made, selects an authentication
* NONE.
*/
@Override
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);
}
}
| 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 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 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 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();
/**
* 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 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;
}
| 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 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);
}
/**
* 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 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;
}
// Public instance methods
// ========================
/**
* Creates a clone of this proxy. Changes made to the clone should not
* affect this object.
*/
@Override
public Object clone() {
Socks4Proxy newProxy = new Socks4Proxy(proxyIP, proxyPort, user);
newProxy.chainProxy = chainProxy;
return newProxy;
}
// Public Static(Class) Methods
// ==============================
// Protected Methods
// =================
@Override
protected Proxy copy() {
Socks4Proxy copy = new Socks4Proxy(proxyIP, proxyPort, user);
copy.chainProxy = chainProxy;
return copy;
}
@Override
protected ProxyMessage formMessage(InputStream in) throws SocksException,
IOException {
return new Socks4Message(in, true);
}
@Override
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);
}
@Override
protected ProxyMessage formMessage(int cmd, String host, int port)
throws UnknownHostException {
return formMessage(cmd, InetAddress.getByName(host), port);
}
}
| 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;
/**
* 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;
/**
* 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();
}
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();
}
/**
* 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();
}
/**
* 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);
}
/**
* 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;
}
/**
* Same as Socket
*/
@Override
public void close() throws IOException {
if (proxy != null)
proxy.endSession();
proxy = null;
}
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);
}
}
/**
* 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.
*/
@Override
public InetAddress getInetAddress() {
if (remoteIP == null) {
try {
remoteIP = InetAddress.getByName(remoteHost);
} catch (UnknownHostException e) {
return null;
}
}
return remoteIP;
}
/**
* Same as Socket
*/
@Override
public InputStream getInputStream() {
return proxy.in;
}
/**
* 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.
*/
@Override
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;
}
/**
* 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.
*/
@Override
public int getLocalPort() {
return localPort;
}
/**
* Same as Socket
*/
@Override
public OutputStream getOutputStream() {
return proxy.out;
}
/**
* Same as Socket
*/
@Override
public int getPort() {
return remotePort;
}
/**
* Same as socket.
*/
public int getSoLinger(int timeout) throws SocketException {
return proxy.proxySocket.getSoLinger();
}
/**
* Same as socket.
*/
public int getSoTimeout(int timeout) throws SocketException {
return proxy.proxySocket.getSoTimeout();
}
/**
* Same as socket.
*/
@Override
public boolean getTcpNoDelay() throws SocketException {
return proxy.proxySocket.getTcpNoDelay();
}
/**
* Same as socket.
*/
@Override
public void setSoLinger(boolean on, int val) throws SocketException {
proxy.proxySocket.setSoLinger(on, val);
}
/**
* Same as socket.
*/
@Override
public void setSoTimeout(int timeout) throws SocketException {
proxy.proxySocket.setSoTimeout(timeout);
}
/**
* Same as socket.
*/
@Override
public void setTcpNoDelay(boolean on) throws SocketException {
proxy.proxySocket.setTcpNoDelay(on);
}
// Private Methods
// ////////////////
/**
* Get string representation of the socket.
*/
@Override
public String toString() {
if (directSock != null)
return "Direct connection:" + directSock;
return ("Proxy:" + proxy + ";" + "addr:" + remoteHost + ",port:"
+ remotePort + ",localport:" + localPort);
}
}
| Java |
package net.sourceforge.jsocks;
/**
* SOCKS5 none authentication. Dummy class does almost nothing.
*/
public class AuthenticationNone implements Authentication {
@Override
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 java.io.IOException;
import java.io.InterruptedIOException;
import java.io.PrintStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import net.sourceforge.jsocks.server.ServerAuthenticator;
/**
* 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
static private void log(String s) {
if (log != null) {
log.println(s);
log.flush();
}
}
// Public methods
// ///////////////
/**
* 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;
}
/**
* 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;
}
/**
* 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);
}
// 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;
}
/**
* IP address to which client should send datagrams for association.
*/
public InetAddress getRelayIP() {
return relayIP;
}
/**
* Port to which client should send datagram for association.
*/
public int getRelayPort() {
return relayPort;
}
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);
}
}
// Runnable interface
// //////////////////
@Override
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.");
}
}
/**
* 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();
}
}
| Java |
package net.sourceforge.jsocks;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* 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);
}
/**
* 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;
}
/**
* 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");
}
/**
* Closes datagram socket, and proxy connection.
*/
@Override
public void close() {
if (!server_mode)
proxy.endSession();
super.close();
}
private byte[] formHeader(InetAddress ip, int port) {
Socks5Message request = new Socks5Message(0, ip, port);
request.data[0] = 0;
return request.data;
}
/**
* 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.
*/
@Override
public InetAddress getLocalAddress() {
if (server_mode)
return super.getLocalAddress();
return relayIP;
}
/**
* 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.
*/
@Override
public int getLocalPort() {
if (server_mode)
return super.getLocalPort();
return relayPort;
}
/**
* 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;
}
/**
* 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.
*/
@Override
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);
}
/**
* 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.
*/
@Override
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));
}
// PRIVATE METHODS
// ////////////////
/**
* 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);
}
/*
* ======================================================================
*
* //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;
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;
/**
* 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.
*/
@Override
public String toString() {
return errString;
}
}// 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
// ///////////////////
static final String command_names[] = { "CONNECT", "BIND", "UDP_ASSOCIATE" };
// Other constructors
// //////////////////
static final String command2String(int cmd) {
if (cmd > 0 && cmd < 4)
return command_names[cmd - 1];
else
return "Unknown Command " + cmd;
}
// Public methods
// ///////////////
/**
* Get proxy.
*
* @return Proxy wich is used to handle user requests.
*/
public static Proxy getProxy() {
return proxy;
}
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 : ""));
}
static final void log(String s) {
if (log != null) {
log.println(s);
log.flush();
}
}
/**
* 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 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);
}
/**
* 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;
}
/**
* 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;
}
/**
* 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);
}
/**
* Creates a proxy server with given Authentication scheme.
*
* @param auth
* Authentication scheme to be used.
*/
public ProxyServer(ServerAuthenticator auth) {
this.auth = auth;
}
protected ProxyServer(ServerAuthenticator auth, Socket s) {
this.auth = auth;
this.sock = s;
mode = START_MODE;
}
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) {
}
}
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);
}
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);
}
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 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 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 methods
// ////////////////
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 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;
}
}
}
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;
}
// Runnable interface
// //////////////////
@Override
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 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) {
}
}
/**
* 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 {
}
}
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 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);
}
/**
* 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) {
}
}
}
| 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 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());
}
/**
* 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());
}
// Public instance methods
// ========================
/**
* Creates a clone of this Proxy.
*/
@Override
@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;
}
@Override
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;
}
@Override
protected ProxyMessage formMessage(InputStream in) throws SocksException,
IOException {
return new Socks5Message(in);
}
@Override
protected ProxyMessage formMessage(int cmd, InetAddress ip, int port) {
return new Socks5Message(cmd, ip, port);
}
@Override
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);
}
// Public Static(Class) Methods
// ==============================
// Protected Methods
// =================
/**
* 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;
}
/**
* 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;
}
/**
* 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;
}
/**
* 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;
}
/**
*
*
*/
@Override
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) 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));
}
}
}
| Java |
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.me.androidapplication1;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.animation.AnimationUtils;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.Gallery;
import android.widget.ImageButton;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.Gallery.LayoutParams;
import android.widget.ImageSwitcher;
import android.widget.ImageView;
import android.widget.ViewSwitcher;
/**
*
* @author daniele
*/
public class TestStreaming extends Activity {
private Button streamButton;
private ImageButton playButton;
private TextView textStreamed;
private boolean isPlaying;
private StreamingMediaPlayer audioStreamer;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
// requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.main);
initControls();
}
protected void onDestroy()
{
super.onDestroy();
Toast.makeText(TestStreaming.this, "...exiting application..." ,Toast.LENGTH_SHORT).show();
if ( audioStreamer != null)
{
audioStreamer.interrupt();
}
}
private void initControls()
{
textStreamed = (TextView) findViewById(R.id.text_kb_streamed);
streamButton = (Button) findViewById(R.id.button_stream);
streamButton.setOnClickListener(new View.OnClickListener()
{
public void onClick(View view)
{
String urlstring2 = "http://shoutcast.unitedradio.it:1101";
Toast
.makeText(
TestStreaming.this,
"The following stream is about to start" + urlstring2,
Toast.LENGTH_LONG).show();
startStreamingAudio(urlstring2);
}
});
playButton = (ImageButton) findViewById(R.id.button_play);
playButton.setEnabled(false);
playButton.setOnClickListener(new View.OnClickListener()
{
public void onClick(View view)
{
if (audioStreamer.getMediaPlayer().isPlaying())
{
audioStreamer.getMediaPlayer().pause();
playButton.setImageResource(R.drawable.button_play);
} else
{
audioStreamer.getMediaPlayer().start();
audioStreamer.startPlayProgressUpdater();
playButton.setImageResource(R.drawable.button_pause);
}
isPlaying = !isPlaying;
}
});
}
private void startStreamingAudio(String urlstring) {
try {
final ProgressBar progressBar = (ProgressBar) findViewById(R.id.progress_bar);
if ( audioStreamer != null) {
audioStreamer.interrupt();
}
audioStreamer = new StreamingMediaPlayer(this,textStreamed, playButton, streamButton,progressBar);
audioStreamer.startStreaming(urlstring,5208, 216);
streamButton.setEnabled(false);
} catch (Exception e)
{
Log.e(getClass().getName(), "Error starting to stream audio.", e);
}
}
public void onItemSelected(AdapterView parent, View v, int position, long id)
{
mSwitcher.setImageResource(mImageIds[position]);
}
public void onNothingSelected(AdapterView parent)
{
}
public View makeView()
{
ImageView i = new ImageView(this);
i.setBackgroundColor(0xFF000000);
i.setScaleType(ImageView.ScaleType.FIT_CENTER);
i.setLayoutParams(new ImageSwitcher.LayoutParams(
LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
return i;
}
private ImageSwitcher mSwitcher;
public class ImageAdapter extends BaseAdapter
{
public ImageAdapter(Context c)
{
mContext = c;
}
public int getCount()
{
return mThumbIds.length;
}
public Object getItem(int position)
{
return position;
}
public long getItemId(int position)
{
return position;
}
public View getView(int position, View convertView, ViewGroup parent)
{
ImageView i = new ImageView(mContext);
i.setImageResource(mThumbIds[position]);
i.setAdjustViewBounds(true);
i.setLayoutParams(new Gallery.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
i.setBackgroundResource(R.drawable.picture_frame);
return i;
}
private Context mContext;
}
private Integer[] mThumbIds =
{ R.drawable.calculator, R.drawable.calendar, R.drawable.camera };
private Integer[] mImageIds =
{ R.drawable.calculator, R.drawable.calendar, R.drawable.camera };
}
| Java |
package org.me.androidapplication1;
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.net.URL;
import java.net.URLConnection;
import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Handler;
import android.util.Log;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.ProgressBar;
import android.widget.TextView;
/**
* MediaPlayer does not yet support streaming from external URLs so this class
* provides a pseudo-streaming function by downloading the content incrementally
* & playing as soon as we get enough audio in our temporary storage.
*/
public class StreamingMediaPlayer
{
private static final int INTIAL_KB_BUFFER = 96 * 10 / 8;// assume
// 96kbps*10secs/8bits
// per byte
private TextView textStreamed;
private ImageButton playButton;
private ProgressBar progressBar;
// Track for display by progressBar
private long mediaLengthInKb, mediaLengthInSeconds;
private int totalKbRead = 0;
// Create Handler to call View updates on the main UI thread.
private final Handler handler = new Handler();
private MediaPlayer mediaPlayer;
private File downloadingMediaFile;
private boolean isInterrupted;
private Context context;
private int counter = 0;
public StreamingMediaPlayer(Context context, TextView textStreamed,
ImageButton playButton, Button streamButton, ProgressBar progressBar)
{
this.context = context;
this.textStreamed = textStreamed;
this.playButton = playButton;
this.progressBar = progressBar;
}
/**
* Progressivly download the media to a temporary location and update the
* MediaPlayer as new content becomes available.
*/
public void startStreaming(final String mediaUrl, long mediaLengthInKb,
long mediaLengthInSeconds) throws IOException
{
this.mediaLengthInKb = mediaLengthInKb;
this.mediaLengthInSeconds = mediaLengthInSeconds;
Runnable r = new Runnable()
{
public void run()
{
try
{
downloadAudioIncrement(mediaUrl);
} catch (IOException e)
{
Log.e(getClass().getName(),
"Unable to initialize the MediaPlayer for fileUrl="
+ mediaUrl, e);
return;
}
}
};
new Thread(r).start();
}
/**
* Download the url stream to a temporary location and then call the
* setDataSource for that local file
*/
public void downloadAudioIncrement(String mediaUrl) throws IOException
{
URLConnection cn = new URL(mediaUrl).openConnection();
cn.connect();
InputStream stream = cn.getInputStream();
if (stream == null)
{
Log.e(getClass().getName(),
"Unable to create InputStream for mediaUrl:" + mediaUrl);
}
downloadingMediaFile = new File(context.getCacheDir(),
"downloadingMedia.dat");
// Just in case a prior deletion failed because our code crashed or
// something, we also delete any previously
// downloaded file to ensure we start fresh. If you use this code,
// always delete
// no longer used downloads else you'll quickly fill up your hard disk
// memory. Of course, you can also
// store any previously downloaded file in a separate data cache for
// instant replay if you wanted as well.
if (downloadingMediaFile.exists())
{
downloadingMediaFile.delete();
}
FileOutputStream out = new FileOutputStream(downloadingMediaFile);
byte buf[] = new byte[16384];
int totalBytesRead = 0, incrementalBytesRead = 0;
do
{
int numread = stream.read(buf);
if (numread <= 0)
break;
out.write(buf, 0, numread);
totalBytesRead += numread;
incrementalBytesRead += numread;
totalKbRead = totalBytesRead / 1000;
testMediaBuffer();
fireDataLoadUpdate();
} while (validateNotInterrupted());
stream.close();
if (validateNotInterrupted())
{
fireDataFullyLoaded();
}
}
private boolean validateNotInterrupted()
{
if (isInterrupted)
{
if (mediaPlayer != null)
{
mediaPlayer.pause();
// mediaPlayer.release();
}
return false;
} else
{
return true;
}
}
/**
* Test whether we need to transfer buffered data to the MediaPlayer.
* Interacting with MediaPlayer on non-main UI thread can causes crashes to
* so perform this using a Handler.
*/
private void testMediaBuffer()
{
Runnable updater = new Runnable()
{
public void run()
{
if (mediaPlayer == null)
{
// Only create the MediaPlayer once we have the minimum
// buffered data
if (totalKbRead >= INTIAL_KB_BUFFER)
{
try
{
startMediaPlayer();
} catch (Exception e)
{
Log.e(getClass().getName(),
"Error copying buffered conent.", e);
}
}
} else if (mediaPlayer.getDuration()
- mediaPlayer.getCurrentPosition() <= 1000)
{
// NOTE: The media player has stopped at the end so transfer
// any existing buffered data
// We test for < 1second of data because the media player
// can stop when there is still
// a few milliseconds of data left to play
transferBufferToMediaPlayer();
}
}
};
handler.post(updater);
}
private void startMediaPlayer()
{
try
{
File bufferedFile = new File(context.getCacheDir(), "playingMedia"
+ (counter++) + ".dat");
// We double buffer the data to avoid potential read/write errors
// that could happen if the
// download thread attempted to write at the same time the
// MediaPlayer was trying to read.
// For example, we can't guarantee that the MediaPlayer won't open a
// file for playing and leave it locked while
// the media is playing. This would permanently deadlock the file
// download. To avoid such a deadloack,
// we move the currently loaded data to a temporary buffer file that
// we start playing while the remaining
// data downloads.
moveFile(downloadingMediaFile, bufferedFile);
Log.e(getClass().getName(),
"Buffered File path: " + bufferedFile.getAbsolutePath());
Log.e(getClass().getName(),
"Buffered File length: " + bufferedFile.length() + "");
mediaPlayer = createMediaPlayer(bufferedFile);
// We have pre-loaded enough content and started the MediaPlayer so
// update the buttons & progress meters.
mediaPlayer.start();
startPlayProgressUpdater();
playButton.setEnabled(true);
} catch (IOException e)
{
Log.e(getClass().getName(), "Error initializing the MediaPlayer.",
e);
return;
}
}
private MediaPlayer createMediaPlayer(File mediaFile) throws IOException
{
MediaPlayer mPlayer = new MediaPlayer();
mPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener()
{
public boolean onError(MediaPlayer mp, int what, int extra)
{
Log.e(getClass().getName(), "Error in MediaPlayer: (" + what
+ ") with extra (" + extra + ")");
return false;
}
});
// It appears that for security/permission reasons, it is better to pass
// a FileDescriptor rather than a direct path to the File.
// Also I have seen errors such as "PVMFErrNotSupported" and
// "Prepare failed.: status=0x1" if a file path String is passed to
// setDataSource(). So unless otherwise noted, we use a FileDescriptor
// here.
FileInputStream fis = new FileInputStream(mediaFile);
mPlayer.setDataSource(fis.getFD());
mPlayer.prepare();
return mPlayer;
}
/**
* Transfer buffered data to the MediaPlayer. NOTE: Interacting with a
* MediaPlayer on a non-main UI thread can cause thread-lock and crashes so
* this method should always be called using a Handler.
*/
private void transferBufferToMediaPlayer()
{
try
{
// First determine if we need to restart the player after
// transferring data...e.g. perhaps the user pressed pause
boolean wasPlaying = mediaPlayer.isPlaying();
int curPosition = mediaPlayer.getCurrentPosition();
// Copy the currently downloaded content to a new buffered File.
// Store the old File for deleting later.
File oldBufferedFile = new File(context.getCacheDir(),
"playingMedia" + counter + ".dat");
File bufferedFile = new File(context.getCacheDir(), "playingMedia"
+ (counter++) + ".dat");
// This may be the last buffered File so ask that it be delete on
// exit. If it's already deleted, then this won't mean anything. If
// you want to
// keep and track fully downloaded files for later use, write
// caching code and please send me a copy.
bufferedFile.deleteOnExit();
moveFile(downloadingMediaFile, bufferedFile);
// Pause the current player now as we are about to create and start
// a new one. So far (Android v1.5),
// this always happens so quickly that the user never realized we've
// stopped the player and started a new one
mediaPlayer.pause();
// Create a new MediaPlayer rather than try to re-prepare the prior
// one.
mediaPlayer = createMediaPlayer(bufferedFile);
mediaPlayer.seekTo(curPosition);
// Restart if at end of prior buffered content or mediaPlayer was
// previously playing.
// NOTE: We test for < 1second of data because the media player can
// stop when there is still
// a few milliseconds of data left to play
boolean atEndOfFile = mediaPlayer.getDuration()
- mediaPlayer.getCurrentPosition() <= 1000;
if (wasPlaying || atEndOfFile)
{
mediaPlayer.start();
}
// Lastly delete the previously playing buffered File as it's no
// longer needed.
oldBufferedFile.delete();
} catch (Exception e)
{
Log.e(getClass().getName(),
"Error updating to newly loaded content.", e);
}
}
private void fireDataLoadUpdate()
{
Runnable updater = new Runnable()
{
public void run()
{
textStreamed.setText((totalKbRead + " Kb read"));
float loadProgress = ((float) totalKbRead / (float) mediaLengthInKb);
progressBar.setSecondaryProgress((int) (loadProgress * 100));
}
};
handler.post(updater);
}
private void fireDataFullyLoaded()
{
Runnable updater = new Runnable()
{
public void run()
{
transferBufferToMediaPlayer();
// Delete the downloaded File as it's now been transferred to
// the currently playing buffer file.
downloadingMediaFile.delete();
textStreamed
.setText(("Audio full loaded: " + totalKbRead + " Kb read"));
}
};
handler.post(updater);
}
public MediaPlayer getMediaPlayer()
{
return mediaPlayer;
}
public void startPlayProgressUpdater()
{
float progress = (((float) mediaPlayer.getCurrentPosition() / 1000) / mediaLengthInSeconds);
progressBar.setProgress((int) (progress * 100));
if (mediaPlayer.isPlaying())
{
Runnable notification = new Runnable()
{
public void run()
{
startPlayProgressUpdater();
}
};
handler.postDelayed(notification, 1000);
}
}
public void interrupt()
{
playButton.setEnabled(false);
isInterrupted = true;
validateNotInterrupted();
}
/**
* Move the file in oldLocation to newLocation.
*/
public void moveFile(File oldLocation, File newLocation) throws IOException
{
if (oldLocation.exists())
{
BufferedInputStream reader = new BufferedInputStream(
new FileInputStream(oldLocation));
BufferedOutputStream writer = new BufferedOutputStream(
new FileOutputStream(newLocation, false));
try
{
// byte[] buff = new byte[8192];
/* changing the size of the buffer */
byte[] buff = new byte[16384];
int numChars;
while ((numChars = reader.read(buff, 0, buff.length)) != -1)
{
writer.write(buff, 0, numChars);
}
} catch (IOException ex)
{
throw new IOException("IOException when transferring "
+ oldLocation.getPath() + " to "
+ newLocation.getPath());
} finally
{
try
{
if (reader != null)
{
writer.close();
reader.close();
}
} catch (IOException ex)
{
Log.e(getClass().getName(),
"Error closing files when transferring "
+ oldLocation.getPath() + " to "
+ newLocation.getPath());
}
}
} else
{
throw new IOException(
"Old location does not exist when transferring "
+ oldLocation.getPath() + " to "
+ newLocation.getPath());
}
}
} | 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;
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.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 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 |
/**
* 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.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.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 |
/*
* 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 |
/*
* 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 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 |
/*
* 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.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 |
/*
* Copyright (C) 2008 OpenIntents.org
*
* 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.openintents.intents;
// Version Dec 9, 2008
/**
* Provides OpenIntents actions, extras, and categories used by providers.
* <p>These specifiers extend the standard Android specifiers.</p>
*/
public final class FileManagerIntents {
/**
* Activity Action: Pick a file through the file manager, or let user
* specify a custom file name.
* Data is the current file name or file name suggestion.
* Returns a new file name as file URI in data.
*
* <p>Constant Value: "org.openintents.action.PICK_FILE"</p>
*/
public static final String ACTION_PICK_FILE = "org.openintents.action.PICK_FILE";
/**
* Activity Action: Pick a directory through the file manager, or let user
* specify a custom file name.
* Data is the current directory name or directory name suggestion.
* Returns a new directory name as file URI in data.
*
* <p>Constant Value: "org.openintents.action.PICK_DIRECTORY"</p>
*/
public static final String ACTION_PICK_DIRECTORY = "org.openintents.action.PICK_DIRECTORY";
/**
* The title to display.
*
* <p>This is shown in the title bar of the file manager.</p>
*
* <p>Constant Value: "org.openintents.extra.TITLE"</p>
*/
public static final String EXTRA_TITLE = "org.openintents.extra.TITLE";
/**
* The text on the button to display.
*
* <p>Depending on the use, it makes sense to set this to "Open" or "Save".</p>
*
* <p>Constant Value: "org.openintents.extra.BUTTON_TEXT"</p>
*/
public static final String EXTRA_BUTTON_TEXT = "org.openintents.extra.BUTTON_TEXT";
}
| Java |
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.niochar.charset.additional;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
/* TODO: support direct byte buffers
import org.apache.harmony.nio.AddressUtil;
import org.apache.harmony.niochar.CharsetProviderImpl;
*/
public class IBM437 extends Charset {
public IBM437(String csName, String[] aliases) {
super(csName, aliases);
}
public boolean contains(Charset cs) {
return cs.name().equalsIgnoreCase("IBM367") || cs.name().equalsIgnoreCase("IBM437") || cs.name().equalsIgnoreCase("US-ASCII") ;
}
public CharsetDecoder newDecoder() {
return new Decoder(this);
}
public CharsetEncoder newEncoder() {
return new Encoder(this);
}
private static final class Decoder extends CharsetDecoder{
private Decoder(Charset cs){
super(cs, 1, 1);
}
private native int nDecode(char[] array, int arrPosition, int remaining, long outAddr, int absolutePos);
protected CoderResult decodeLoop(ByteBuffer bb, CharBuffer cb){
int cbRemaining = cb.remaining();
/* TODO: support direct byte buffers
if(CharsetProviderImpl.hasLoadedNatives() && bb.isDirect() && bb.hasRemaining() && cb.hasArray()){
int toProceed = bb.remaining();
int cbPos = cb.position();
int bbPos = bb.position();
boolean throwOverflow = false;
if( cbRemaining < toProceed ) {
toProceed = cbRemaining;
throwOverflow = true;
}
int res = nDecode(cb.array(), cb.arrayOffset()+cbPos, toProceed, AddressUtil.getDirectBufferAddress(bb), bbPos);
bb.position(bbPos+res);
cb.position(cbPos+res);
if(throwOverflow) return CoderResult.OVERFLOW;
}else{
*/
if(bb.hasArray() && cb.hasArray()) {
int rem = bb.remaining();
rem = cbRemaining >= rem ? rem : cbRemaining;
byte[] bArr = bb.array();
char[] cArr = cb.array();
int bStart = bb.position();
int cStart = cb.position();
int i;
for(i=bStart; i<bStart+rem; i++) {
char in = (char)(bArr[i] & 0xFF);
if(in >= 26){
int index = (int)in - 26;
cArr[cStart++] = (char)arr[index];
}else {
cArr[cStart++] = (char)(in & 0xFF);
}
}
bb.position(i);
cb.position(cStart);
if(rem == cbRemaining && bb.hasRemaining()) return CoderResult.OVERFLOW;
} else {
while(bb.hasRemaining()){
if( cbRemaining == 0 ) return CoderResult.OVERFLOW;
char in = (char)(bb.get() & 0xFF);
if(in >= 26){
int index = (int)in - 26;
cb.put(arr[index]);
}else {
cb.put((char)(in & 0xFF));
}
cbRemaining--;
}
/*
}
*/
}
return CoderResult.UNDERFLOW;
}
final static char[] arr = {
0x001C,0x001B,0x007F,0x001D,0x001E,0x001F,
0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,
0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,
0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,
0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,
0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,
0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,
0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,
0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,
0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,
0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,
0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,
0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,0x001A,
0x00C7,0x00FC,0x00E9,0x00E2,0x00E4,0x00E0,0x00E5,0x00E7,
0x00EA,0x00EB,0x00E8,0x00EF,0x00EE,0x00EC,0x00C4,0x00C5,
0x00C9,0x00E6,0x00C6,0x00F4,0x00F6,0x00F2,0x00FB,0x00F9,
0x00FF,0x00D6,0x00DC,0x00A2,0x00A3,0x00A5,0x20A7,0x0192,
0x00E1,0x00ED,0x00F3,0x00FA,0x00F1,0x00D1,0x00AA,0x00BA,
0x00BF,0x2310,0x00AC,0x00BD,0x00BC,0x00A1,0x00AB,0x00BB,
0x2591,0x2592,0x2593,0x2502,0x2524,0x2561,0x2562,0x2556,
0x2555,0x2563,0x2551,0x2557,0x255D,0x255C,0x255B,0x2510,
0x2514,0x2534,0x252C,0x251C,0x2500,0x253C,0x255E,0x255F,
0x255A,0x2554,0x2569,0x2566,0x2560,0x2550,0x256C,0x2567,
0x2568,0x2564,0x2565,0x2559,0x2558,0x2552,0x2553,0x256B,
0x256A,0x2518,0x250C,0x2588,0x2584,0x258C,0x2590,0x2580,
0x03B1,0x00DF,0x0393,0x03C0,0x03A3,0x03C3,0x03BC,0x03C4,
0x03A6,0x0398,0x03A9,0x03B4,0x221E,0x03C6,0x03B5,0x2229,
0x2261,0x00B1,0x2265,0x2264,0x2320,0x2321,0x00F7,0x2248,
0x00B0,0x2219,0x00B7,0x221A,0x207F,0x00B2,0x25A0,0x00A0
};
}
private static final class Encoder extends CharsetEncoder{
private Encoder(Charset cs){
super(cs, 1, 1);
}
private native void nEncode(long outAddr, int absolutePos, char[] array, int arrPosition, int[] res);
protected CoderResult encodeLoop(CharBuffer cb, ByteBuffer bb){
int bbRemaining = bb.remaining();
/* TODO: support direct byte buffers
if(CharsetProviderImpl.hasLoadedNatives() && bb.isDirect() && cb.hasRemaining() && cb.hasArray()){
int toProceed = cb.remaining();
int cbPos = cb.position();
int bbPos = bb.position();
boolean throwOverflow = false;
if( bbRemaining < toProceed ) {
toProceed = bbRemaining;
throwOverflow = true;
}
int[] res = {toProceed, 0};
nEncode(AddressUtil.getDirectBufferAddress(bb), bbPos, cb.array(), cb.arrayOffset()+cbPos, res);
if( res[0] <= 0 ) {
bb.position(bbPos-res[0]);
cb.position(cbPos-res[0]);
if(res[1]!=0) {
if(res[1] < 0)
return CoderResult.malformedForLength(-res[1]);
else
return CoderResult.unmappableForLength(res[1]);
}
}else{
bb.position(bbPos+res[0]);
cb.position(cbPos+res[0]);
if(throwOverflow) return CoderResult.OVERFLOW;
}
}else{
*/
if(bb.hasArray() && cb.hasArray()) {
byte[] byteArr = bb.array();
char[] charArr = cb.array();
int rem = cb.remaining();
int byteArrStart = bb.position();
rem = bbRemaining <= rem ? bbRemaining : rem;
int x;
for(x = cb.position(); x < cb.position()+rem; x++) {
char c = charArr[x];
if(c > (char)0x25A0){
if (c >= 0xD800 && c <= 0xDFFF) {
if(x+1 < cb.limit()) {
char c1 = charArr[x+1];
if(c1 >= 0xD800 && c1 <= 0xDFFF) {
cb.position(x); bb.position(byteArrStart);
return CoderResult.unmappableForLength(2);
}
} else {
cb.position(x); bb.position(byteArrStart);
return CoderResult.UNDERFLOW;
}
cb.position(x); bb.position(byteArrStart);
return CoderResult.malformedForLength(1);
}
cb.position(x); bb.position(byteArrStart);
return CoderResult.unmappableForLength(1);
}else{
if(c < 0x1A) {
byteArr[byteArrStart++] = (byte)c;
} else {
int index = (int)c >> 8;
index = encodeIndex[index];
if(index < 0) {
cb.position(x); bb.position(byteArrStart);
return CoderResult.unmappableForLength(1);
}
index <<= 8;
index += (int)c & 0xFF;
if((byte)arr[index] != 0){
byteArr[byteArrStart++] = (byte)arr[index];
}else{
cb.position(x); bb.position(byteArrStart);
return CoderResult.unmappableForLength(1);
}
}
}
}
cb.position(x);
bb.position(byteArrStart);
if(rem == bbRemaining && cb.hasRemaining()) {
return CoderResult.OVERFLOW;
}
} else {
while(cb.hasRemaining()){
if( bbRemaining == 0 ) return CoderResult.OVERFLOW;
char c = cb.get();
if(c > (char)0x25A0){
if (c >= 0xD800 && c <= 0xDFFF) {
if(cb.hasRemaining()) {
char c1 = cb.get();
if(c1 >= 0xD800 && c1 <= 0xDFFF) {
cb.position(cb.position()-2);
return CoderResult.unmappableForLength(2);
} else {
cb.position(cb.position()-1);
}
} else {
cb.position(cb.position()-1);
return CoderResult.UNDERFLOW;
}
cb.position(cb.position()-1);
return CoderResult.malformedForLength(1);
}
cb.position(cb.position()-1);
return CoderResult.unmappableForLength(1);
}else{
if(c < 0x1A) {
bb.put((byte)c);
} else {
int index = (int)c >> 8;
index = encodeIndex[index];
if(index < 0) {
cb.position(cb.position()-1);
return CoderResult.unmappableForLength(1);
}
index <<= 8;
index += (int)c & 0xFF;
if((byte)arr[index] != 0){
bb.put((byte)arr[index]);
}else{
cb.position(cb.position()-1);
return CoderResult.unmappableForLength(1);
}
}
bbRemaining--;
}
}
/* TODO: support direct byte buffers
}
*/
}
return CoderResult.UNDERFLOW;
}
final static char arr[] = {
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x7F,0x1B,0x1A,0x1D,0x1E,0x1F,
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x1C,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xFF,0xAD,0x9B,0x9C,0x00,0x9D,0x00,0x00,0x00,0x00,0xA6,0xAE,0xAA,0x00,0x00,0x00,
0xF8,0xF1,0xFD,0x00,0x00,0x00,0x00,0xFA,0x00,0x00,0xA7,0xAF,0xAC,0xAB,0x00,0xA8,
0x00,0x00,0x00,0x00,0x8E,0x8F,0x92,0x80,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0xA5,0x00,0x00,0x00,0x00,0x99,0x00,0x00,0x00,0x00,0x00,0x9A,0x00,0x00,0xE1,
0x85,0xA0,0x83,0x00,0x84,0x86,0x91,0x87,0x8A,0x82,0x88,0x89,0x8D,0xA1,0x8C,0x8B,
0x00,0xA4,0x95,0xA2,0x93,0x00,0x94,0xF6,0x00,0x97,0xA3,0x96,0x81,0x00,0x00,0x98,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x9F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xE2,0x00,0x00,0x00,0x00,0xE9,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xE4,0x00,0x00,0xE8,0x00,0x00,0xEA,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0xE0,0x00,0x00,0xEB,0xEE,0x00,0x00,0x00,0x00,0x00,0x00,0xE6,0x00,0x00,0x00,
0xE3,0x00,0x00,0xE5,0xE7,0x00,0xED,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x9E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF9,0xFB,0x00,0x00,0x00,0xEC,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xEF,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0xF0,0x00,0x00,0xF3,0xF2,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xA9,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xF4,0xF5,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xC4,0x00,0xB3,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xDA,0x00,0x00,0x00,
0xBF,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0xD9,0x00,0x00,0x00,0xC3,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0xB4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC2,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0xC1,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC5,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xCD,0xBA,0xD5,0xD6,0xC9,0xB8,0xB7,0xBB,0xD4,0xD3,0xC8,0xBE,0xBD,0xBC,0xC6,0xC7,
0xCC,0xB5,0xB6,0xB9,0xD1,0xD2,0xCB,0xCF,0xD0,0xCA,0xD8,0xD7,0xCE,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xDF,0x00,0x00,0x00,0xDC,0x00,0x00,0x00,0xDB,0x00,0x00,0x00,0xDD,0x00,0x00,0x00,
0xDE,0xB0,0xB1,0xB2,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
final static int[] encodeIndex = {
0,1,-1,2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
3,-1,4,5,-1,6,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-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 java.util.Arrays;
import java.util.List;
import org.connectbot.util.Colors;
import org.connectbot.util.HostDatabase;
import org.connectbot.util.UberColorPickerDialog;
import org.connectbot.util.UberColorPickerDialog.OnColorChangedListener;
import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.MenuItem.OnMenuItemClickListener;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.GridView;
import android.widget.Spinner;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemSelectedListener;
/**
* @author Kenny Root
*
*/
public class ColorsActivity extends Activity implements OnItemClickListener, OnColorChangedListener, OnItemSelectedListener {
private GridView mColorGrid;
private Spinner mFgSpinner;
private Spinner mBgSpinner;
private int mColorScheme;
private List<Integer> mColorList;
private HostDatabase hostdb;
private int mCurrentColor = 0;
private int[] mDefaultColors;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.act_colors);
this.setTitle(String.format("%s: %s",
getResources().getText(R.string.app_name),
getResources().getText(R.string.title_colors)));
mColorScheme = HostDatabase.DEFAULT_COLOR_SCHEME;
hostdb = new HostDatabase(this);
mColorList = Arrays.asList(hostdb.getColorsForScheme(mColorScheme));
mDefaultColors = hostdb.getDefaultColorsForScheme(mColorScheme);
mColorGrid = (GridView) findViewById(R.id.color_grid);
mColorGrid.setAdapter(new ColorsAdapter(true));
mColorGrid.setOnItemClickListener(this);
mColorGrid.setSelection(0);
mFgSpinner = (Spinner) findViewById(R.id.fg);
mFgSpinner.setAdapter(new ColorsAdapter(false));
mFgSpinner.setSelection(mDefaultColors[0]);
mFgSpinner.setOnItemSelectedListener(this);
mBgSpinner = (Spinner) findViewById(R.id.bg);
mBgSpinner.setAdapter(new ColorsAdapter(false));
mBgSpinner.setSelection(mDefaultColors[1]);
mBgSpinner.setOnItemSelectedListener(this);
}
@Override
protected void onDestroy() {
super.onDestroy();
if (hostdb != null) {
hostdb.close();
hostdb = null;
}
}
@Override
protected void onResume() {
super.onResume();
if (hostdb == null)
hostdb = new HostDatabase(this);
}
private class ColorsAdapter extends BaseAdapter {
private boolean mSquareViews;
public ColorsAdapter(boolean squareViews) {
mSquareViews = squareViews;
}
public View getView(int position, View convertView, ViewGroup parent) {
ColorView c;
if (convertView == null) {
c = new ColorView(ColorsActivity.this, mSquareViews);
} else {
c = (ColorView) convertView;
}
c.setColor(mColorList.get(position));
c.setNumber(position + 1);
return c;
}
public int getCount() {
return mColorList.size();
}
public Object getItem(int position) {
return mColorList.get(position);
}
public long getItemId(int position) {
return position;
}
}
private class ColorView extends View {
private boolean mSquare;
private Paint mTextPaint;
private Paint mShadowPaint;
// Things we paint
private int mBackgroundColor;
private String mText;
private int mAscent;
private int mWidthCenter;
private int mHeightCenter;
public ColorView(Context context, boolean square) {
super(context);
mSquare = square;
mTextPaint = new Paint();
mTextPaint.setAntiAlias(true);
mTextPaint.setTextSize(16);
mTextPaint.setColor(0xFFFFFFFF);
mTextPaint.setTextAlign(Paint.Align.CENTER);
mShadowPaint = new Paint(mTextPaint);
mShadowPaint.setStyle(Paint.Style.STROKE);
mShadowPaint.setStrokeCap(Paint.Cap.ROUND);
mShadowPaint.setStrokeJoin(Paint.Join.ROUND);
mShadowPaint.setStrokeWidth(4f);
mShadowPaint.setColor(0xFF000000);
setPadding(10, 10, 10, 10);
}
public void setColor(int color) {
mBackgroundColor = color;
}
public void setNumber(int number) {
mText = Integer.toString(number);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int width = measureWidth(widthMeasureSpec);
int height;
if (mSquare)
height = width;
else
height = measureHeight(heightMeasureSpec);
mAscent = (int) mTextPaint.ascent();
mWidthCenter = width / 2;
mHeightCenter = height / 2 - mAscent / 2;
setMeasuredDimension(width, height);
}
private int measureWidth(int measureSpec) {
int result = 0;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
if (specMode == MeasureSpec.EXACTLY) {
// We were told how big to be
result = specSize;
} else {
// Measure the text
result = (int) mTextPaint.measureText(mText) + getPaddingLeft()
+ getPaddingRight();
if (specMode == MeasureSpec.AT_MOST) {
// Respect AT_MOST value if that was what is called for by
// measureSpec
result = Math.min(result, specSize);
}
}
return result;
}
private int measureHeight(int measureSpec) {
int result = 0;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
mAscent = (int) mTextPaint.ascent();
if (specMode == MeasureSpec.EXACTLY) {
// We were told how big to be
result = specSize;
} else {
// Measure the text (beware: ascent is a negative number)
result = (int) (-mAscent + mTextPaint.descent())
+ getPaddingTop() + getPaddingBottom();
if (specMode == MeasureSpec.AT_MOST) {
// Respect AT_MOST value if that was what is called for by
// measureSpec
result = Math.min(result, specSize);
}
}
return result;
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawColor(mBackgroundColor);
canvas.drawText(mText, mWidthCenter, mHeightCenter, mShadowPaint);
canvas.drawText(mText, mWidthCenter, mHeightCenter, mTextPaint);
}
}
private void editColor(int colorNumber) {
mCurrentColor = colorNumber;
new UberColorPickerDialog(this, this, mColorList.get(colorNumber)).show();
}
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
editColor(position);
}
public void onNothingSelected(AdapterView<?> arg0) { }
public void colorChanged(int value) {
hostdb.setGlobalColor(mCurrentColor, value);
mColorList.set(mCurrentColor, value);
mColorGrid.invalidateViews();
}
public void onItemSelected(AdapterView<?> parent, View view, int position,
long id) {
boolean needUpdate = false;
if (parent == mFgSpinner) {
if (position != mDefaultColors[0]) {
mDefaultColors[0] = position;
needUpdate = true;
}
} else if (parent == mBgSpinner) {
if (position != mDefaultColors[1]) {
mDefaultColors[1] = position;
needUpdate = true;
}
}
if (needUpdate)
hostdb.setDefaultColorsForScheme(mColorScheme, mDefaultColors[0], mDefaultColors[1]);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
MenuItem reset = menu.add(R.string.menu_colors_reset);
reset.setAlphabeticShortcut('r');
reset.setNumericShortcut('1');
reset.setIcon(android.R.drawable.ic_menu_revert);
reset.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem arg0) {
// Reset each individual color to defaults.
for (int i = 0; i < Colors.defaults.length; i++) {
if (mColorList.get(i) != Colors.defaults[i]) {
hostdb.setGlobalColor(i, Colors.defaults[i]);
mColorList.set(i, Colors.defaults[i]);
}
}
mColorGrid.invalidateViews();
// Reset the default FG/BG colors as well.
mFgSpinner.setSelection(HostDatabase.DEFAULT_FG_COLOR);
mBgSpinner.setSelection(HostDatabase.DEFAULT_BG_COLOR);
hostdb.setDefaultColorsForScheme(HostDatabase.DEFAULT_COLOR_SCHEME,
HostDatabase.DEFAULT_FG_COLOR, HostDatabase.DEFAULT_BG_COLOR);
return true;
}
});
return true;
}
}
| 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.service;
public interface BridgeDisconnectedListener {
public void onDisconnected(TerminalBridge bridge);
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2010 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.service;
import org.connectbot.util.PreferenceConstants;
import android.app.backup.BackupManager;
import android.content.Context;
/**
* @author kroot
*
*/
public abstract class BackupWrapper {
public static BackupWrapper getInstance() {
if (PreferenceConstants.PRE_FROYO)
return PreFroyo.Holder.sInstance;
else
return FroyoAndBeyond.Holder.sInstance;
}
public abstract void onDataChanged(Context context);
private static class PreFroyo extends BackupWrapper {
private static class Holder {
private static final PreFroyo sInstance = new PreFroyo();
}
@Override
public void onDataChanged(Context context) {
// do nothing for now
}
}
private static class FroyoAndBeyond extends BackupWrapper {
private static class Holder {
private static final FroyoAndBeyond sInstance = new FroyoAndBeyond();
}
private static BackupManager mBackupManager;
@Override
public void onDataChanged(Context context) {
checkBackupManager(context);
if (mBackupManager != null) {
mBackupManager.dataChanged();
}
}
private void checkBackupManager(Context context) {
if (mBackupManager == null) {
mBackupManager = new BackupManager(context);
}
}
}
}
| 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.service;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import org.apache.harmony.niochar.charset.additional.IBM437;
import org.connectbot.transport.AbsTransport;
import org.connectbot.util.EastAsianWidth;
import android.util.Log;
import de.mud.terminal.vt320;
/**
* @author Kenny Root
*/
public class Relay implements Runnable {
private static final String TAG = "ConnectBot.Relay";
private static final int BUFFER_SIZE = 4096;
private TerminalBridge bridge;
private Charset currentCharset;
private CharsetDecoder decoder;
private AbsTransport transport;
private vt320 buffer;
private ByteBuffer byteBuffer;
private CharBuffer charBuffer;
private byte[] byteArray;
private char[] charArray;
public Relay(TerminalBridge bridge, AbsTransport transport, vt320 buffer, String encoding) {
setCharset(encoding);
this.bridge = bridge;
this.transport = transport;
this.buffer = buffer;
}
public void setCharset(String encoding) {
Log.d("ConnectBot.Relay", "changing charset to " + encoding);
Charset charset;
if (encoding.equals("CP437"))
charset = new IBM437("IBM437",
new String[] { "IBM437", "CP437" });
else
charset = Charset.forName(encoding);
if (charset == currentCharset || charset == null)
return;
CharsetDecoder newCd = charset.newDecoder();
newCd.onUnmappableCharacter(CodingErrorAction.REPLACE);
newCd.onMalformedInput(CodingErrorAction.REPLACE);
currentCharset = charset;
synchronized (this) {
decoder = newCd;
}
}
public Charset getCharset() {
return currentCharset;
}
public void run() {
byteBuffer = ByteBuffer.allocate(BUFFER_SIZE);
charBuffer = CharBuffer.allocate(BUFFER_SIZE);
/* for East Asian character widths */
byte[] wideAttribute = new byte[BUFFER_SIZE];
byteArray = byteBuffer.array();
charArray = charBuffer.array();
CoderResult result;
int bytesRead = 0;
byteBuffer.limit(0);
int bytesToRead;
int offset;
int charWidth;
EastAsianWidth measurer = EastAsianWidth.getInstance();
try {
while (true) {
charWidth = bridge.charWidth;
bytesToRead = byteBuffer.capacity() - byteBuffer.limit();
offset = byteBuffer.arrayOffset() + byteBuffer.limit();
bytesRead = transport.read(byteArray, offset, bytesToRead);
if (bytesRead > 0) {
byteBuffer.limit(byteBuffer.limit() + bytesRead);
synchronized (this) {
result = decoder.decode(byteBuffer, charBuffer, false);
}
if (result.isUnderflow() &&
byteBuffer.limit() == byteBuffer.capacity()) {
byteBuffer.compact();
byteBuffer.limit(byteBuffer.position());
byteBuffer.position(0);
}
offset = charBuffer.position();
measurer.measure(charArray, 0, offset, wideAttribute, bridge.defaultPaint, charWidth);
buffer.putString(charArray, wideAttribute, 0, charBuffer.position());
bridge.propagateConsoleText(charArray, charBuffer.position());
charBuffer.clear();
bridge.redraw();
}
}
} catch (IOException e) {
Log.e(TAG, "Problem while handling incoming data in relay thread", e);
}
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2010 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.service;
import java.io.IOException;
import org.connectbot.util.HostDatabase;
import org.connectbot.util.PreferenceConstants;
import org.connectbot.util.PubkeyDatabase;
import android.app.backup.BackupAgentHelper;
import android.app.backup.BackupDataInput;
import android.app.backup.BackupDataOutput;
import android.app.backup.FileBackupHelper;
import android.app.backup.SharedPreferencesBackupHelper;
import android.os.ParcelFileDescriptor;
import android.util.Log;
/**
* @author kroot
*
*/
public class BackupAgent extends BackupAgentHelper {
@Override
public void onCreate() {
Log.d("ConnectBot.BackupAgent", "onCreate called");
SharedPreferencesBackupHelper prefs = new SharedPreferencesBackupHelper(this, getPackageName() + "_preferences");
addHelper(PreferenceConstants.BACKUP_PREF_KEY, prefs);
FileBackupHelper hosts = new FileBackupHelper(this, "../databases/" + HostDatabase.DB_NAME);
addHelper(HostDatabase.DB_NAME, hosts);
FileBackupHelper pubkeys = new FileBackupHelper(this, "../databases/" + PubkeyDatabase.DB_NAME);
addHelper(PubkeyDatabase.DB_NAME, pubkeys);
}
@Override
public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data,
ParcelFileDescriptor newState) throws IOException {
synchronized (HostDatabase.dbLock) {
super.onBackup(oldState, data, newState);
}
}
@Override
public void onRestore(BackupDataInput data, int appVersionCode,
ParcelFileDescriptor newState) throws IOException {
Log.d("ConnectBot.BackupAgent", "onRestore called");
synchronized (HostDatabase.dbLock) {
Log.d("ConnectBot.BackupAgent", "onRestore in-lock");
super.onRestore(data, appVersionCode, newState);
}
}
}
| 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.service;
/**
* @author Kenny Root
*
*/
public interface FontSizeChangedListener {
/**
* @param size
* new font size
*/
void onFontSizeChanged(float size);
}
| 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.service;
import java.util.concurrent.Semaphore;
import android.os.Handler;
import android.os.Message;
/**
* Helps provide a relay for prompts and responses between a possible user
* interface and some underlying service.
*
* @author jsharkey
*/
public class PromptHelper {
private final Object tag;
private Handler handler = null;
private Semaphore promptToken;
private Semaphore promptResponse;
public String promptInstructions = null;
public String promptHint = null;
public Object promptRequested = null;
private Object response = null;
public PromptHelper(Object tag) {
this.tag = tag;
// Threads must acquire this before they can send a prompt.
promptToken = new Semaphore(1);
// Responses will release this semaphore.
promptResponse = new Semaphore(0);
}
/**
* Register a user interface handler, if available.
*/
public void setHandler(Handler handler) {
this.handler = handler;
}
/**
* Set an incoming value from an above user interface. Will automatically
* notify any waiting requests.
*/
public void setResponse(Object value) {
response = value;
promptRequested = null;
promptInstructions = null;
promptHint = null;
promptResponse.release();
}
/**
* Return the internal response value just before erasing and returning it.
*/
protected Object popResponse() {
Object value = response;
response = null;
return value;
}
/**
* Request a prompt response from parent. This is a blocking call until user
* interface returns a value.
* Only one thread can call this at a time. cancelPrompt() will force this to
* immediately return.
*/
private Object requestPrompt(String instructions, String hint, Object type) throws InterruptedException {
Object response = null;
promptToken.acquire();
try {
promptInstructions = instructions;
promptHint = hint;
promptRequested = type;
// notify any parent watching for live events
if (handler != null)
Message.obtain(handler, -1, tag).sendToTarget();
// acquire lock until user passes back value
promptResponse.acquire();
response = popResponse();
} finally {
promptToken.release();
}
return response;
}
/**
* Request a string response from parent. This is a blocking call until user
* interface returns a value.
* @param hint prompt hint for user to answer
* @return string user has entered
*/
public String requestStringPrompt(String instructions, String hint) {
String value = null;
try {
value = (String)this.requestPrompt(instructions, hint, String.class);
} catch(Exception e) {
}
return value;
}
/**
* Request a boolean response from parent. This is a blocking call until user
* interface returns a value.
* @param hint prompt hint for user to answer
* @return choice user has made (yes/no)
*/
public Boolean requestBooleanPrompt(String instructions, String hint) {
Boolean value = null;
try {
value = (Boolean)this.requestPrompt(instructions, hint, Boolean.class);
} catch(Exception e) {
}
return value;
}
/**
* Cancel an in-progress prompt.
*/
public void cancelPrompt() {
if (!promptToken.tryAcquire()) {
// A thread has the token, so try to interrupt it
response = null;
promptResponse.release();
} else {
// No threads have acquired the token
promptToken.release();
}
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2010 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.service;
import java.io.IOException;
import org.connectbot.TerminalView;
import org.connectbot.bean.SelectionArea;
import org.connectbot.util.PreferenceConstants;
import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.content.res.Configuration;
import android.preference.PreferenceManager;
import android.text.ClipboardManager;
import android.util.Log;
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnKeyListener;
import de.mud.terminal.VDUBuffer;
import de.mud.terminal.vt320;
/**
* @author kenny
*
*/
@SuppressWarnings("deprecation") // for ClipboardManager
public class TerminalKeyListener implements OnKeyListener, OnSharedPreferenceChangeListener {
private static final String TAG = "ConnectBot.OnKeyListener";
public final static int META_CTRL_ON = 0x01;
public final static int META_CTRL_LOCK = 0x02;
public final static int META_ALT_ON = 0x04;
public final static int META_ALT_LOCK = 0x08;
public final static int META_SHIFT_ON = 0x10;
public final static int META_SHIFT_LOCK = 0x20;
public final static int META_SLASH = 0x40;
public final static int META_TAB = 0x80;
// The bit mask of momentary and lock states for each
public final static int META_CTRL_MASK = META_CTRL_ON | META_CTRL_LOCK;
public final static int META_ALT_MASK = META_ALT_ON | META_ALT_LOCK;
public final static int META_SHIFT_MASK = META_SHIFT_ON | META_SHIFT_LOCK;
// backport constants from api level 11
public final static int KEYCODE_ESCAPE = 111;
public final static int HC_META_CTRL_ON = 4096;
// All the transient key codes
public final static int META_TRANSIENT = META_CTRL_ON | META_ALT_ON
| META_SHIFT_ON;
private final TerminalManager manager;
private final TerminalBridge bridge;
private final VDUBuffer buffer;
private String keymode = null;
private boolean hardKeyboard = false;
private int metaState = 0;
private int mDeadKey = 0;
// TODO add support for the new API.
private ClipboardManager clipboard = null;
private boolean selectingForCopy = false;
private final SelectionArea selectionArea;
private String encoding;
private final SharedPreferences prefs;
public TerminalKeyListener(TerminalManager manager,
TerminalBridge bridge,
VDUBuffer buffer,
String encoding) {
this.manager = manager;
this.bridge = bridge;
this.buffer = buffer;
this.encoding = encoding;
selectionArea = new SelectionArea();
prefs = PreferenceManager.getDefaultSharedPreferences(manager);
prefs.registerOnSharedPreferenceChangeListener(this);
hardKeyboard = (manager.res.getConfiguration().keyboard
== Configuration.KEYBOARD_QWERTY);
updateKeymode();
}
/**
* Handle onKey() events coming down from a {@link TerminalView} above us.
* Modify the keys to make more sense to a host then pass it to the transport.
*/
public boolean onKey(View v, int keyCode, KeyEvent event) {
try {
final boolean hardKeyboardHidden = manager.hardKeyboardHidden;
// Ignore all key-up events except for the special keys
if (event.getAction() == KeyEvent.ACTION_UP) {
// There's nothing here for virtual keyboard users.
if (!hardKeyboard || (hardKeyboard && hardKeyboardHidden))
return false;
// skip keys if we aren't connected yet or have been disconnected
if (bridge.isDisconnected() || bridge.transport == null)
return false;
if (PreferenceConstants.KEYMODE_RIGHT.equals(keymode)) {
if (keyCode == KeyEvent.KEYCODE_ALT_RIGHT
&& (metaState & META_SLASH) != 0) {
metaState &= ~(META_SLASH | META_TRANSIENT);
bridge.transport.write('/');
return true;
} else if (keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT
&& (metaState & META_TAB) != 0) {
metaState &= ~(META_TAB | META_TRANSIENT);
bridge.transport.write(0x09);
return true;
}
} else if (PreferenceConstants.KEYMODE_LEFT.equals(keymode)) {
if (keyCode == KeyEvent.KEYCODE_ALT_LEFT
&& (metaState & META_SLASH) != 0) {
metaState &= ~(META_SLASH | META_TRANSIENT);
bridge.transport.write('/');
return true;
} else if (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT
&& (metaState & META_TAB) != 0) {
metaState &= ~(META_TAB | META_TRANSIENT);
bridge.transport.write(0x09);
return true;
}
}
return false;
}
// check for terminal resizing keys
if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
bridge.increaseFontSize();
return true;
} else if(keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
bridge.decreaseFontSize();
return true;
}
// skip keys if we aren't connected yet or have been disconnected
if (bridge.isDisconnected() || bridge.transport == null)
return false;
bridge.resetScrollPosition();
if (keyCode == KeyEvent.KEYCODE_UNKNOWN &&
event.getAction() == KeyEvent.ACTION_MULTIPLE) {
byte[] input = event.getCharacters().getBytes(encoding);
bridge.transport.write(input);
return true;
}
int curMetaState = event.getMetaState();
final int orgMetaState = curMetaState;
if ((metaState & META_SHIFT_MASK) != 0) {
curMetaState |= KeyEvent.META_SHIFT_ON;
}
if ((metaState & META_ALT_MASK) != 0) {
curMetaState |= KeyEvent.META_ALT_ON;
}
int key = event.getUnicodeChar(curMetaState);
// no hard keyboard? ALT-k should pass through to below
if ((orgMetaState & KeyEvent.META_ALT_ON) != 0 &&
(!hardKeyboard || hardKeyboardHidden)) {
key = 0;
}
if ((key & KeyCharacterMap.COMBINING_ACCENT) != 0) {
mDeadKey = key & KeyCharacterMap.COMBINING_ACCENT_MASK;
return true;
}
if (mDeadKey != 0) {
key = KeyCharacterMap.getDeadChar(mDeadKey, keyCode);
mDeadKey = 0;
}
final boolean printing = (key != 0);
// otherwise pass through to existing session
// print normal keys
if (printing) {
metaState &= ~(META_SLASH | META_TAB);
// Remove shift and alt modifiers
final int lastMetaState = metaState;
metaState &= ~(META_SHIFT_ON | META_ALT_ON);
if (metaState != lastMetaState) {
bridge.redraw();
}
if ((metaState & META_CTRL_MASK) != 0) {
metaState &= ~META_CTRL_ON;
bridge.redraw();
// If there is no hard keyboard or there is a hard keyboard currently hidden,
// CTRL-1 through CTRL-9 will send F1 through F9
if ((!hardKeyboard || (hardKeyboard && hardKeyboardHidden))
&& sendFunctionKey(keyCode))
return true;
key = keyAsControl(key);
}
// handle pressing f-keys
if ((hardKeyboard && !hardKeyboardHidden)
&& (curMetaState & KeyEvent.META_SHIFT_ON) != 0
&& sendFunctionKey(keyCode))
return true;
if (key < 0x80)
bridge.transport.write(key);
else
// TODO write encoding routine that doesn't allocate each time
bridge.transport.write(new String(Character.toChars(key))
.getBytes(encoding));
return true;
}
// send ctrl and meta-keys as appropriate
if (!hardKeyboard || hardKeyboardHidden) {
int k = event.getUnicodeChar(0);
int k0 = k;
boolean sendCtrl = false;
boolean sendMeta = false;
if (k != 0) {
if ((orgMetaState & HC_META_CTRL_ON) != 0) {
k = keyAsControl(k);
if (k != k0)
sendCtrl = true;
// send F1-F10 via CTRL-1 through CTRL-0
if (!sendCtrl && sendFunctionKey(keyCode))
return true;
} else if ((orgMetaState & KeyEvent.META_ALT_ON) != 0) {
sendMeta = true;
sendEscape();
}
if (sendMeta || sendCtrl) {
bridge.transport.write(k);
return true;
}
}
}
// try handling keymode shortcuts
if (hardKeyboard && !hardKeyboardHidden &&
event.getRepeatCount() == 0) {
if (PreferenceConstants.KEYMODE_RIGHT.equals(keymode)) {
switch (keyCode) {
case KeyEvent.KEYCODE_ALT_RIGHT:
metaState |= META_SLASH;
return true;
case KeyEvent.KEYCODE_SHIFT_RIGHT:
metaState |= META_TAB;
return true;
case KeyEvent.KEYCODE_SHIFT_LEFT:
metaPress(META_SHIFT_ON);
return true;
case KeyEvent.KEYCODE_ALT_LEFT:
metaPress(META_ALT_ON);
return true;
}
} else if (PreferenceConstants.KEYMODE_LEFT.equals(keymode)) {
switch (keyCode) {
case KeyEvent.KEYCODE_ALT_LEFT:
metaState |= META_SLASH;
return true;
case KeyEvent.KEYCODE_SHIFT_LEFT:
metaState |= META_TAB;
return true;
case KeyEvent.KEYCODE_SHIFT_RIGHT:
metaPress(META_SHIFT_ON);
return true;
case KeyEvent.KEYCODE_ALT_RIGHT:
metaPress(META_ALT_ON);
return true;
}
} else {
switch (keyCode) {
case KeyEvent.KEYCODE_ALT_LEFT:
case KeyEvent.KEYCODE_ALT_RIGHT:
metaPress(META_ALT_ON);
return true;
case KeyEvent.KEYCODE_SHIFT_LEFT:
case KeyEvent.KEYCODE_SHIFT_RIGHT:
metaPress(META_SHIFT_ON);
return true;
}
}
}
// look for special chars
switch(keyCode) {
case KEYCODE_ESCAPE:
sendEscape();
return true;
case KeyEvent.KEYCODE_TAB:
bridge.transport.write(0x09);
return true;
case KeyEvent.KEYCODE_CAMERA:
// check to see which shortcut the camera button triggers
String camera = manager.prefs.getString(
PreferenceConstants.CAMERA,
PreferenceConstants.CAMERA_CTRLA_SPACE);
if(PreferenceConstants.CAMERA_CTRLA_SPACE.equals(camera)) {
bridge.transport.write(0x01);
bridge.transport.write(' ');
} else if(PreferenceConstants.CAMERA_CTRLA.equals(camera)) {
bridge.transport.write(0x01);
} else if(PreferenceConstants.CAMERA_ESC.equals(camera)) {
((vt320)buffer).keyTyped(vt320.KEY_ESCAPE, ' ', 0);
} else if(PreferenceConstants.CAMERA_ESC_A.equals(camera)) {
((vt320)buffer).keyTyped(vt320.KEY_ESCAPE, ' ', 0);
bridge.transport.write('a');
}
break;
case KeyEvent.KEYCODE_DEL:
((vt320) buffer).keyPressed(vt320.KEY_BACK_SPACE, ' ',
getStateForBuffer());
metaState &= ~META_TRANSIENT;
return true;
case KeyEvent.KEYCODE_ENTER:
((vt320)buffer).keyTyped(vt320.KEY_ENTER, ' ', 0);
metaState &= ~META_TRANSIENT;
return true;
case KeyEvent.KEYCODE_DPAD_LEFT:
if (selectingForCopy) {
selectionArea.decrementColumn();
bridge.redraw();
} else {
((vt320) buffer).keyPressed(vt320.KEY_LEFT, ' ',
getStateForBuffer());
metaState &= ~META_TRANSIENT;
bridge.tryKeyVibrate();
}
return true;
case KeyEvent.KEYCODE_DPAD_UP:
if (selectingForCopy) {
selectionArea.decrementRow();
bridge.redraw();
} else {
((vt320) buffer).keyPressed(vt320.KEY_UP, ' ',
getStateForBuffer());
metaState &= ~META_TRANSIENT;
bridge.tryKeyVibrate();
}
return true;
case KeyEvent.KEYCODE_DPAD_DOWN:
if (selectingForCopy) {
selectionArea.incrementRow();
bridge.redraw();
} else {
((vt320) buffer).keyPressed(vt320.KEY_DOWN, ' ',
getStateForBuffer());
metaState &= ~META_TRANSIENT;
bridge.tryKeyVibrate();
}
return true;
case KeyEvent.KEYCODE_DPAD_RIGHT:
if (selectingForCopy) {
selectionArea.incrementColumn();
bridge.redraw();
} else {
((vt320) buffer).keyPressed(vt320.KEY_RIGHT, ' ',
getStateForBuffer());
metaState &= ~META_TRANSIENT;
bridge.tryKeyVibrate();
}
return true;
case KeyEvent.KEYCODE_DPAD_CENTER:
if (selectingForCopy) {
if (selectionArea.isSelectingOrigin())
selectionArea.finishSelectingOrigin();
else {
if (clipboard != null) {
// copy selected area to clipboard
String copiedText = selectionArea.copyFrom(buffer);
clipboard.setText(copiedText);
// XXX STOPSHIP
// manager.notifyUser(manager.getString(
// R.string.console_copy_done,
// copiedText.length()));
selectingForCopy = false;
selectionArea.reset();
}
}
} else {
if ((metaState & META_CTRL_ON) != 0) {
sendEscape();
metaState &= ~META_CTRL_ON;
} else
metaPress(META_CTRL_ON);
}
bridge.redraw();
return true;
}
} catch (IOException e) {
Log.e(TAG, "Problem while trying to handle an onKey() event", e);
try {
bridge.transport.flush();
} catch (IOException ioe) {
Log.d(TAG, "Our transport was closed, dispatching disconnect event");
bridge.dispatchDisconnect(false);
}
} catch (NullPointerException npe) {
Log.d(TAG, "Input before connection established ignored.");
return true;
}
return false;
}
public int keyAsControl(int key) {
// Support CTRL-a through CTRL-z
if (key >= 0x61 && key <= 0x7A)
key -= 0x60;
// Support CTRL-A through CTRL-_
else if (key >= 0x41 && key <= 0x5F)
key -= 0x40;
// CTRL-space sends NULL
else if (key == 0x20)
key = 0x00;
// CTRL-? sends DEL
else if (key == 0x3F)
key = 0x7F;
return key;
}
public void sendEscape() {
((vt320)buffer).keyTyped(vt320.KEY_ESCAPE, ' ', 0);
}
/**
* @param key
* @return successful
*/
private boolean sendFunctionKey(int keyCode) {
switch (keyCode) {
case KeyEvent.KEYCODE_1:
((vt320) buffer).keyPressed(vt320.KEY_F1, ' ', 0);
return true;
case KeyEvent.KEYCODE_2:
((vt320) buffer).keyPressed(vt320.KEY_F2, ' ', 0);
return true;
case KeyEvent.KEYCODE_3:
((vt320) buffer).keyPressed(vt320.KEY_F3, ' ', 0);
return true;
case KeyEvent.KEYCODE_4:
((vt320) buffer).keyPressed(vt320.KEY_F4, ' ', 0);
return true;
case KeyEvent.KEYCODE_5:
((vt320) buffer).keyPressed(vt320.KEY_F5, ' ', 0);
return true;
case KeyEvent.KEYCODE_6:
((vt320) buffer).keyPressed(vt320.KEY_F6, ' ', 0);
return true;
case KeyEvent.KEYCODE_7:
((vt320) buffer).keyPressed(vt320.KEY_F7, ' ', 0);
return true;
case KeyEvent.KEYCODE_8:
((vt320) buffer).keyPressed(vt320.KEY_F8, ' ', 0);
return true;
case KeyEvent.KEYCODE_9:
((vt320) buffer).keyPressed(vt320.KEY_F9, ' ', 0);
return true;
case KeyEvent.KEYCODE_0:
((vt320) buffer).keyPressed(vt320.KEY_F10, ' ', 0);
return true;
default:
return false;
}
}
/**
* Handle meta key presses where the key can be locked on.
* <p>
* 1st press: next key to have meta state<br />
* 2nd press: meta state is locked on<br />
* 3rd press: disable meta state
*
* @param code
*/
public void metaPress(int code) {
if ((metaState & (code << 1)) != 0) {
metaState &= ~(code << 1);
} else if ((metaState & code) != 0) {
metaState &= ~code;
metaState |= code << 1;
} else
metaState |= code;
bridge.redraw();
}
public void setTerminalKeyMode(String keymode) {
this.keymode = keymode;
}
private int getStateForBuffer() {
int bufferState = 0;
if ((metaState & META_CTRL_MASK) != 0)
bufferState |= vt320.KEY_CONTROL;
if ((metaState & META_SHIFT_MASK) != 0)
bufferState |= vt320.KEY_SHIFT;
if ((metaState & META_ALT_MASK) != 0)
bufferState |= vt320.KEY_ALT;
return bufferState;
}
public int getMetaState() {
return metaState;
}
public int getDeadKey() {
return mDeadKey;
}
public void setClipboardManager(ClipboardManager clipboard) {
this.clipboard = clipboard;
}
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
String key) {
if (PreferenceConstants.KEYMODE.equals(key)) {
updateKeymode();
}
}
private void updateKeymode() {
keymode = prefs.getString(PreferenceConstants.KEYMODE, PreferenceConstants.KEYMODE_RIGHT);
}
public void setCharset(String encoding) {
this.encoding = encoding;
}
}
| 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.service;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Timer;
import java.util.TimerTask;
import org.connectbot.R;
import org.connectbot.bean.HostBean;
import org.connectbot.bean.PubkeyBean;
import org.connectbot.transport.TransportFactory;
import org.connectbot.util.HostDatabase;
import org.connectbot.util.PreferenceConstants;
import org.connectbot.util.PubkeyDatabase;
import org.connectbot.util.PubkeyUtils;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.content.res.AssetFileDescriptor;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.net.Uri;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Vibrator;
import android.preference.PreferenceManager;
import android.util.Log;
/**
* Manager for SSH connections that runs as a service. This service holds a list
* of currently connected SSH bridges that are ready for connection up to a GUI
* if needed.
*
* @author jsharkey
*/
public class TerminalManager extends Service implements BridgeDisconnectedListener, OnSharedPreferenceChangeListener {
public final static String TAG = "ConnectBot.TerminalManager";
public List<TerminalBridge> bridges = new LinkedList<TerminalBridge>();
public Map<HostBean, WeakReference<TerminalBridge>> mHostBridgeMap =
new HashMap<HostBean, WeakReference<TerminalBridge>>();
public Map<String, WeakReference<TerminalBridge>> mNicknameBridgeMap =
new HashMap<String, WeakReference<TerminalBridge>>();
public TerminalBridge defaultBridge = null;
public List<HostBean> disconnected = new LinkedList<HostBean>();
public Handler disconnectHandler = null;
public Map<String, KeyHolder> loadedKeypairs = new HashMap<String, KeyHolder>();
public Resources res;
public HostDatabase hostdb;
public PubkeyDatabase pubkeydb;
protected SharedPreferences prefs;
final private IBinder binder = new TerminalBinder();
private ConnectivityReceiver connectivityManager;
private MediaPlayer mediaPlayer;
private Timer pubkeyTimer;
private Timer idleTimer;
private final long IDLE_TIMEOUT = 300000; // 5 minutes
private Vibrator vibrator;
private volatile boolean wantKeyVibration;
public static final long VIBRATE_DURATION = 30;
private boolean wantBellVibration;
private boolean resizeAllowed = true;
private boolean savingKeys;
protected List<WeakReference<TerminalBridge>> mPendingReconnect
= new LinkedList<WeakReference<TerminalBridge>>();
public boolean hardKeyboardHidden;
@Override
public void onCreate() {
Log.i(TAG, "Starting service");
prefs = PreferenceManager.getDefaultSharedPreferences(this);
prefs.registerOnSharedPreferenceChangeListener(this);
res = getResources();
pubkeyTimer = new Timer("pubkeyTimer", true);
hostdb = new HostDatabase(this);
pubkeydb = new PubkeyDatabase(this);
// load all marked pubkeys into memory
updateSavingKeys();
List<PubkeyBean> pubkeys = pubkeydb.getAllStartPubkeys();
for (PubkeyBean pubkey : pubkeys) {
try {
PrivateKey privKey = PubkeyUtils.decodePrivate(pubkey.getPrivateKey(), pubkey.getType());
PublicKey pubKey = pubkey.getPublicKey();
Object trileadKey = PubkeyUtils.convertToTrilead(privKey, pubKey);
addKey(pubkey, trileadKey);
} catch (Exception e) {
Log.d(TAG, String.format("Problem adding key '%s' to in-memory cache", pubkey.getNickname()), e);
}
}
vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
wantKeyVibration = prefs.getBoolean(PreferenceConstants.BUMPY_ARROWS, true);
wantBellVibration = prefs.getBoolean(PreferenceConstants.BELL_VIBRATE, true);
enableMediaPlayer();
hardKeyboardHidden = (res.getConfiguration().hardKeyboardHidden ==
Configuration.HARDKEYBOARDHIDDEN_YES);
final boolean lockingWifi = prefs.getBoolean(PreferenceConstants.WIFI_LOCK, true);
connectivityManager = new ConnectivityReceiver(this, lockingWifi);
}
private void updateSavingKeys() {
savingKeys = prefs.getBoolean(PreferenceConstants.MEMKEYS, true);
}
@Override
public void onDestroy() {
Log.i(TAG, "Destroying service");
disconnectAll(true);
if(hostdb != null) {
hostdb.close();
hostdb = null;
}
if(pubkeydb != null) {
pubkeydb.close();
pubkeydb = null;
}
synchronized (this) {
if (idleTimer != null)
idleTimer.cancel();
if (pubkeyTimer != null)
pubkeyTimer.cancel();
}
connectivityManager.cleanup();
ConnectionNotifier.getInstance().hideRunningNotification(this);
disableMediaPlayer();
}
/**
* Disconnect all currently connected bridges.
*/
private void disconnectAll(final boolean immediate) {
TerminalBridge[] tmpBridges = null;
synchronized (bridges) {
if (bridges.size() > 0) {
tmpBridges = bridges.toArray(new TerminalBridge[bridges.size()]);
}
}
if (tmpBridges != null) {
// disconnect and dispose of any existing bridges
for (int i = 0; i < tmpBridges.length; i++)
tmpBridges[i].dispatchDisconnect(immediate);
}
}
/**
* Open a new SSH session using the given parameters.
*/
private TerminalBridge openConnection(HostBean host) throws IllegalArgumentException, IOException {
// throw exception if terminal already open
if (getConnectedBridge(host) != null) {
throw new IllegalArgumentException("Connection already open for that nickname");
}
TerminalBridge bridge = new TerminalBridge(this, host);
bridge.setOnDisconnectedListener(this);
bridge.startConnection();
synchronized (bridges) {
bridges.add(bridge);
WeakReference<TerminalBridge> wr = new WeakReference<TerminalBridge>(bridge);
mHostBridgeMap.put(bridge.host, wr);
mNicknameBridgeMap.put(bridge.host.getNickname(), wr);
}
synchronized (disconnected) {
disconnected.remove(bridge.host);
}
if (bridge.isUsingNetwork()) {
connectivityManager.incRef();
}
if (prefs.getBoolean(PreferenceConstants.CONNECTION_PERSIST, true)) {
ConnectionNotifier.getInstance().showRunningNotification(this);
}
// also update database with new connected time
touchHost(host);
return bridge;
}
public String getEmulation() {
return prefs.getString(PreferenceConstants.EMULATION, "screen");
}
public int getScrollback() {
int scrollback = 140;
try {
scrollback = Integer.parseInt(prefs.getString(PreferenceConstants.SCROLLBACK, "140"));
} catch(Exception e) {
}
return scrollback;
}
/**
* Open a new connection by reading parameters from the given URI. Follows
* format specified by an individual transport.
*/
public TerminalBridge openConnection(Uri uri) throws Exception {
HostBean host = TransportFactory.findHost(hostdb, uri);
if (host == null)
host = TransportFactory.getTransport(uri.getScheme()).createHost(uri);
return openConnection(host);
}
/**
* Update the last-connected value for the given nickname by passing through
* to {@link HostDatabase}.
*/
private void touchHost(HostBean host) {
hostdb.touchHost(host);
}
/**
* Find a connected {@link TerminalBridge} with the given HostBean.
*
* @param host the HostBean to search for
* @return TerminalBridge that uses the HostBean
*/
public TerminalBridge getConnectedBridge(HostBean host) {
WeakReference<TerminalBridge> wr = mHostBridgeMap.get(host);
if (wr != null) {
return wr.get();
} else {
return null;
}
}
/**
* Find a connected {@link TerminalBridge} using its nickname.
*
* @param nickname
* @return TerminalBridge that matches nickname
*/
public TerminalBridge getConnectedBridge(final String nickname) {
if (nickname == null) {
return null;
}
WeakReference<TerminalBridge> wr = mNicknameBridgeMap.get(nickname);
if (wr != null) {
return wr.get();
} else {
return null;
}
}
/**
* Called by child bridge when somehow it's been disconnected.
*/
public void onDisconnected(TerminalBridge bridge) {
boolean shouldHideRunningNotification = false;
synchronized (bridges) {
// remove this bridge from our list
bridges.remove(bridge);
mHostBridgeMap.remove(bridge.host);
mNicknameBridgeMap.remove(bridge.host.getNickname());
if (bridge.isUsingNetwork()) {
connectivityManager.decRef();
}
if (bridges.size() == 0 &&
mPendingReconnect.size() == 0) {
shouldHideRunningNotification = true;
}
}
synchronized (disconnected) {
disconnected.add(bridge.host);
}
if (shouldHideRunningNotification) {
ConnectionNotifier.getInstance().hideRunningNotification(this);
}
// pass notification back up to gui
if (disconnectHandler != null)
Message.obtain(disconnectHandler, -1, bridge).sendToTarget();
}
public boolean isKeyLoaded(String nickname) {
return loadedKeypairs.containsKey(nickname);
}
public void addKey(PubkeyBean pubkey, Object trileadKey) {
addKey(pubkey, trileadKey, false);
}
public void addKey(PubkeyBean pubkey, Object trileadKey, boolean force) {
if (!savingKeys && !force)
return;
removeKey(pubkey.getNickname());
byte[] sshPubKey = PubkeyUtils.extractOpenSSHPublic(trileadKey);
KeyHolder keyHolder = new KeyHolder();
keyHolder.bean = pubkey;
keyHolder.trileadKey = trileadKey;
keyHolder.openSSHPubkey = sshPubKey;
loadedKeypairs.put(pubkey.getNickname(), keyHolder);
if (pubkey.getLifetime() > 0) {
final String nickname = pubkey.getNickname();
pubkeyTimer.schedule(new TimerTask() {
@Override
public void run() {
Log.d(TAG, "Unloading from memory key: " + nickname);
removeKey(nickname);
}
}, pubkey.getLifetime() * 1000);
}
Log.d(TAG, String.format("Added key '%s' to in-memory cache", pubkey.getNickname()));
}
public boolean removeKey(String nickname) {
Log.d(TAG, String.format("Removed key '%s' to in-memory cache", nickname));
return loadedKeypairs.remove(nickname) != null;
}
public boolean removeKey(byte[] publicKey) {
String nickname = null;
for (Entry<String,KeyHolder> entry : loadedKeypairs.entrySet()) {
if (Arrays.equals(entry.getValue().openSSHPubkey, publicKey)) {
nickname = entry.getKey();
break;
}
}
if (nickname != null) {
Log.d(TAG, String.format("Removed key '%s' to in-memory cache", nickname));
return removeKey(nickname);
} else
return false;
}
public Object getKey(String nickname) {
if (loadedKeypairs.containsKey(nickname)) {
KeyHolder keyHolder = loadedKeypairs.get(nickname);
return keyHolder.trileadKey;
} else
return null;
}
public Object getKey(byte[] publicKey) {
for (KeyHolder keyHolder : loadedKeypairs.values()) {
if (Arrays.equals(keyHolder.openSSHPubkey, publicKey))
return keyHolder.trileadKey;
}
return null;
}
public String getKeyNickname(byte[] publicKey) {
for (Entry<String,KeyHolder> entry : loadedKeypairs.entrySet()) {
if (Arrays.equals(entry.getValue().openSSHPubkey, publicKey))
return entry.getKey();
}
return null;
}
private void stopWithDelay() {
// TODO add in a way to check whether keys loaded are encrypted and only
// set timer when we have an encrypted key loaded
if (loadedKeypairs.size() > 0) {
synchronized (this) {
if (idleTimer == null)
idleTimer = new Timer("idleTimer", true);
idleTimer.schedule(new IdleTask(), IDLE_TIMEOUT);
}
} else {
Log.d(TAG, "Stopping service immediately");
stopSelf();
}
}
protected void stopNow() {
if (bridges.size() == 0) {
stopSelf();
}
}
private synchronized void stopIdleTimer() {
if (idleTimer != null) {
idleTimer.cancel();
idleTimer = null;
}
}
public class TerminalBinder extends Binder {
public TerminalManager getService() {
return TerminalManager.this;
}
}
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG, "Someone bound to TerminalManager");
setResizeAllowed(true);
stopIdleTimer();
// Make sure we stay running to maintain the bridges
startService(new Intent(this, TerminalManager.class));
return binder;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
/*
* We want this service to continue running until it is explicitly
* stopped, so return sticky.
*/
return START_STICKY;
}
@Override
public void onRebind(Intent intent) {
super.onRebind(intent);
setResizeAllowed(true);
Log.i(TAG, "Someone rebound to TerminalManager");
stopIdleTimer();
}
@Override
public boolean onUnbind(Intent intent) {
Log.i(TAG, "Someone unbound from TerminalManager");
setResizeAllowed(true);
if (bridges.size() == 0) {
stopWithDelay();
}
return true;
}
private class IdleTask extends TimerTask {
/* (non-Javadoc)
* @see java.util.TimerTask#run()
*/
@Override
public void run() {
Log.d(TAG, String.format("Stopping service after timeout of ~%d seconds", IDLE_TIMEOUT / 1000));
TerminalManager.this.stopNow();
}
}
public void tryKeyVibrate() {
if (wantKeyVibration)
vibrate();
}
private void vibrate() {
if (vibrator != null)
vibrator.vibrate(VIBRATE_DURATION);
}
private void enableMediaPlayer() {
mediaPlayer = new MediaPlayer();
float volume = prefs.getFloat(PreferenceConstants.BELL_VOLUME,
PreferenceConstants.DEFAULT_BELL_VOLUME);
mediaPlayer.setAudioStreamType(AudioManager.STREAM_NOTIFICATION);
mediaPlayer.setOnCompletionListener(new BeepListener());
AssetFileDescriptor file = res.openRawResourceFd(R.raw.bell);
try {
mediaPlayer.setDataSource(file.getFileDescriptor(), file
.getStartOffset(), file.getLength());
file.close();
mediaPlayer.setVolume(volume, volume);
mediaPlayer.prepare();
} catch (IOException e) {
Log.e(TAG, "Error setting up bell media player", e);
}
}
private void disableMediaPlayer() {
if (mediaPlayer != null) {
mediaPlayer.release();
mediaPlayer = null;
}
}
public void playBeep() {
if (mediaPlayer != null)
mediaPlayer.start();
if (wantBellVibration)
vibrate();
}
private static class BeepListener implements OnCompletionListener {
public void onCompletion(MediaPlayer mp) {
mp.seekTo(0);
}
}
/**
* Send system notification to user for a certain host. When user selects
* the notification, it will bring them directly to the ConsoleActivity
* displaying the host.
*
* @param host
*/
public void sendActivityNotification(HostBean host) {
if (!prefs.getBoolean(PreferenceConstants.BELL_NOTIFICATION, false))
return;
ConnectionNotifier.getInstance().showActivityNotification(this, host);
}
/* (non-Javadoc)
* @see android.content.SharedPreferences.OnSharedPreferenceChangeListener#onSharedPreferenceChanged(android.content.SharedPreferences, java.lang.String)
*/
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
String key) {
if (PreferenceConstants.BELL.equals(key)) {
boolean wantAudible = sharedPreferences.getBoolean(
PreferenceConstants.BELL, true);
if (wantAudible && mediaPlayer == null)
enableMediaPlayer();
else if (!wantAudible && mediaPlayer != null)
disableMediaPlayer();
} else if (PreferenceConstants.BELL_VOLUME.equals(key)) {
if (mediaPlayer != null) {
float volume = sharedPreferences.getFloat(
PreferenceConstants.BELL_VOLUME,
PreferenceConstants.DEFAULT_BELL_VOLUME);
mediaPlayer.setVolume(volume, volume);
}
} else if (PreferenceConstants.BELL_VIBRATE.equals(key)) {
wantBellVibration = sharedPreferences.getBoolean(
PreferenceConstants.BELL_VIBRATE, true);
} else if (PreferenceConstants.BUMPY_ARROWS.equals(key)) {
wantKeyVibration = sharedPreferences.getBoolean(
PreferenceConstants.BUMPY_ARROWS, true);
} else if (PreferenceConstants.WIFI_LOCK.equals(key)) {
final boolean lockingWifi = prefs.getBoolean(PreferenceConstants.WIFI_LOCK, true);
connectivityManager.setWantWifiLock(lockingWifi);
} else if (PreferenceConstants.MEMKEYS.equals(key)) {
updateSavingKeys();
}
}
/**
* Allow {@link TerminalBridge} to resize when the parent has changed.
* @param resizeAllowed
*/
public void setResizeAllowed(boolean resizeAllowed) {
this.resizeAllowed = resizeAllowed;
}
public boolean isResizeAllowed() {
return resizeAllowed;
}
public static class KeyHolder {
public PubkeyBean bean;
public Object trileadKey;
public byte[] openSSHPubkey;
}
/**
* Called when connectivity to the network is lost and it doesn't appear
* we'll be getting a different connection any time soon.
*/
public void onConnectivityLost() {
final Thread t = new Thread() {
@Override
public void run() {
disconnectAll(false);
}
};
t.setName("Disconnector");
t.start();
}
/**
* Called when connectivity to the network is restored.
*/
public void onConnectivityRestored() {
final Thread t = new Thread() {
@Override
public void run() {
reconnectPending();
}
};
t.setName("Reconnector");
t.start();
}
/**
* Insert request into reconnect queue to be executed either immediately
* or later when connectivity is restored depending on whether we're
* currently connected.
*
* @param bridge the TerminalBridge to reconnect when possible
*/
public void requestReconnect(TerminalBridge bridge) {
synchronized (mPendingReconnect) {
mPendingReconnect.add(new WeakReference<TerminalBridge>(bridge));
if (!bridge.isUsingNetwork() ||
connectivityManager.isConnected()) {
reconnectPending();
}
}
}
/**
* Reconnect all bridges that were pending a reconnect when connectivity
* was lost.
*/
private void reconnectPending() {
synchronized (mPendingReconnect) {
for (WeakReference<TerminalBridge> ref : mPendingReconnect) {
TerminalBridge bridge = ref.get();
if (bridge == null) {
continue;
}
bridge.startConnection();
}
mPendingReconnect.clear();
}
}
}
| Java |
/*
* ConnectBot: simple, powerful, open-source SSH client for Android
* Copyright 2010 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.service;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.connectbot.ConsoleActivity;
import org.connectbot.R;
import org.connectbot.bean.HostBean;
import org.connectbot.util.HostDatabase;
import org.connectbot.util.PreferenceConstants;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.graphics.Color;
/**
* @author Kenny Root
*
* Based on the concept from jasta's blog post.
*/
public abstract class ConnectionNotifier {
private static final int ONLINE_NOTIFICATION = 1;
private static final int ACTIVITY_NOTIFICATION = 2;
public static ConnectionNotifier getInstance() {
if (PreferenceConstants.PRE_ECLAIR)
return PreEclair.Holder.sInstance;
else
return EclairAndBeyond.Holder.sInstance;
}
protected NotificationManager getNotificationManager(Context context) {
return (NotificationManager)context.getSystemService(Context.NOTIFICATION_SERVICE);
}
protected Notification newNotification(Context context) {
Notification notification = new Notification();
notification.icon = R.drawable.notification_icon;
notification.when = System.currentTimeMillis();
return notification;
}
protected Notification newActivityNotification(Context context, HostBean host) {
Notification notification = newNotification(context);
Resources res = context.getResources();
String contentText = res.getString(
R.string.notification_text, host.getNickname());
Intent notificationIntent = new Intent(context, ConsoleActivity.class);
notificationIntent.setAction("android.intent.action.VIEW");
notificationIntent.setData(host.getUri());
PendingIntent contentIntent = PendingIntent.getActivity(context, 0,
notificationIntent, 0);
notification.setLatestEventInfo(context, res.getString(R.string.app_name), contentText, contentIntent);
notification.flags = Notification.FLAG_AUTO_CANCEL;
notification.flags |= Notification.DEFAULT_LIGHTS;
if (HostDatabase.COLOR_RED.equals(host.getColor()))
notification.ledARGB = Color.RED;
else if (HostDatabase.COLOR_GREEN.equals(host.getColor()))
notification.ledARGB = Color.GREEN;
else if (HostDatabase.COLOR_BLUE.equals(host.getColor()))
notification.ledARGB = Color.BLUE;
else
notification.ledARGB = Color.WHITE;
notification.ledOnMS = 300;
notification.ledOffMS = 1000;
notification.flags |= Notification.FLAG_SHOW_LIGHTS;
return notification;
}
protected Notification newRunningNotification(Context context) {
Notification notification = newNotification(context);
notification.flags = Notification.FLAG_ONGOING_EVENT
| Notification.FLAG_NO_CLEAR;
notification.when = 0;
notification.contentIntent = PendingIntent.getActivity(context,
ONLINE_NOTIFICATION,
new Intent(context, ConsoleActivity.class), 0);
Resources res = context.getResources();
notification.setLatestEventInfo(context,
res.getString(R.string.app_name),
res.getString(R.string.app_is_running),
notification.contentIntent);
return notification;
}
public void showActivityNotification(Service context, HostBean host) {
getNotificationManager(context).notify(ACTIVITY_NOTIFICATION, newActivityNotification(context, host));
}
public void hideActivityNotification(Service context) {
getNotificationManager(context).cancel(ACTIVITY_NOTIFICATION);
}
public abstract void showRunningNotification(Service context);
public abstract void hideRunningNotification(Service context);
private static class PreEclair extends ConnectionNotifier {
private static final Class<?>[] setForegroundSignature = new Class[] {boolean.class};
private Method setForeground = null;
private static class Holder {
private static final PreEclair sInstance = new PreEclair();
}
public PreEclair() {
try {
setForeground = Service.class.getMethod("setForeground", setForegroundSignature);
} catch (Exception e) {
}
}
@Override
public void showRunningNotification(Service context) {
if (setForeground != null) {
Object[] setForegroundArgs = new Object[1];
setForegroundArgs[0] = Boolean.TRUE;
try {
setForeground.invoke(context, setForegroundArgs);
} catch (InvocationTargetException e) {
} catch (IllegalAccessException e) {
}
getNotificationManager(context).notify(ONLINE_NOTIFICATION, newRunningNotification(context));
}
}
@Override
public void hideRunningNotification(Service context) {
if (setForeground != null) {
Object[] setForegroundArgs = new Object[1];
setForegroundArgs[0] = Boolean.FALSE;
try {
setForeground.invoke(context, setForegroundArgs);
} catch (InvocationTargetException e) {
} catch (IllegalAccessException e) {
}
getNotificationManager(context).cancel(ONLINE_NOTIFICATION);
}
}
}
private static class EclairAndBeyond extends ConnectionNotifier {
private static class Holder {
private static final EclairAndBeyond sInstance = new EclairAndBeyond();
}
@Override
public void showRunningNotification(Service context) {
context.startForeground(ONLINE_NOTIFICATION, newRunningNotification(context));
}
@Override
public void hideRunningNotification(Service context) {
context.stopForeground(true);
}
}
}
| 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.service;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.connectbot.R;
import org.connectbot.TerminalView;
import org.connectbot.bean.HostBean;
import org.connectbot.bean.PortForwardBean;
import org.connectbot.bean.SelectionArea;
import org.connectbot.transport.AbsTransport;
import org.connectbot.transport.TransportFactory;
import org.connectbot.util.HostDatabase;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.FontMetrics;
import android.graphics.Typeface;
import android.text.ClipboardManager;
import android.util.Log;
import de.mud.terminal.VDUBuffer;
import de.mud.terminal.VDUDisplay;
import de.mud.terminal.vt320;
/**
* Provides a bridge between a MUD terminal buffer and a possible TerminalView.
* This separation allows us to keep the TerminalBridge running in a background
* service. A TerminalView shares down a bitmap that we can use for rendering
* when available.
*
* This class also provides SSH hostkey verification prompting, and password
* prompting.
*/
@SuppressWarnings("deprecation") // for ClipboardManager
public class TerminalBridge implements VDUDisplay {
public final static String TAG = "ConnectBot.TerminalBridge";
public final static int DEFAULT_FONT_SIZE = 10;
private final static int FONT_SIZE_STEP = 2;
public Integer[] color;
public int defaultFg = HostDatabase.DEFAULT_FG_COLOR;
public int defaultBg = HostDatabase.DEFAULT_BG_COLOR;
protected final TerminalManager manager;
public HostBean host;
/* package */ AbsTransport transport;
final Paint defaultPaint;
private Relay relay;
private final String emulation;
private final int scrollback;
public Bitmap bitmap = null;
public VDUBuffer buffer = null;
private TerminalView parent = null;
private final Canvas canvas = new Canvas();
private boolean disconnected = false;
private boolean awaitingClose = false;
private boolean forcedSize = false;
private int columns;
private int rows;
/* package */ final TerminalKeyListener keyListener;
private boolean selectingForCopy = false;
private final SelectionArea selectionArea;
// TODO add support for the new clipboard API
private ClipboardManager clipboard;
public int charWidth = -1;
public int charHeight = -1;
private int charTop = -1;
private float fontSize = -1;
private final List<FontSizeChangedListener> fontSizeChangedListeners;
private final List<String> localOutput;
/**
* Flag indicating if we should perform a full-screen redraw during our next
* rendering pass.
*/
private boolean fullRedraw = false;
public PromptHelper promptHelper;
protected BridgeDisconnectedListener disconnectListener = null;
/**
* Create a new terminal bridge suitable for unit testing.
*/
public TerminalBridge() {
buffer = new vt320() {
@Override
public void write(byte[] b) {}
@Override
public void write(int b) {}
@Override
public void sendTelnetCommand(byte cmd) {}
@Override
public void setWindowSize(int c, int r) {}
@Override
public void debug(String s) {}
};
emulation = null;
manager = null;
defaultPaint = new Paint();
selectionArea = new SelectionArea();
scrollback = 1;
localOutput = new LinkedList<String>();
fontSizeChangedListeners = new LinkedList<FontSizeChangedListener>();
transport = null;
keyListener = new TerminalKeyListener(manager, this, buffer, null);
}
/**
* Create new terminal bridge with following parameters. We will immediately
* launch thread to start SSH connection and handle any hostkey verification
* and password authentication.
*/
public TerminalBridge(final TerminalManager manager, final HostBean host) throws IOException {
this.manager = manager;
this.host = host;
emulation = manager.getEmulation();
scrollback = manager.getScrollback();
// create prompt helper to relay password and hostkey requests up to gui
promptHelper = new PromptHelper(this);
// create our default paint
defaultPaint = new Paint();
defaultPaint.setAntiAlias(true);
defaultPaint.setTypeface(Typeface.MONOSPACE);
defaultPaint.setFakeBoldText(true); // more readable?
localOutput = new LinkedList<String>();
fontSizeChangedListeners = new LinkedList<FontSizeChangedListener>();
int hostFontSize = host.getFontSize();
if (hostFontSize <= 0)
hostFontSize = DEFAULT_FONT_SIZE;
setFontSize(hostFontSize);
// create terminal buffer and handle outgoing data
// this is probably status reply information
buffer = new vt320() {
@Override
public void debug(String s) {
Log.d(TAG, s);
}
@Override
public void write(byte[] b) {
try {
if (b != null && transport != null)
transport.write(b);
} catch (IOException e) {
Log.e(TAG, "Problem writing outgoing data in vt320() thread", e);
}
}
@Override
public void write(int b) {
try {
if (transport != null)
transport.write(b);
} catch (IOException e) {
Log.e(TAG, "Problem writing outgoing data in vt320() thread", e);
}
}
// We don't use telnet sequences.
@Override
public void sendTelnetCommand(byte cmd) {
}
// We don't want remote to resize our window.
@Override
public void setWindowSize(int c, int r) {
}
@Override
public void beep() {
if (parent.isShown())
manager.playBeep();
else
manager.sendActivityNotification(host);
}
};
// Don't keep any scrollback if a session is not being opened.
if (host.getWantSession())
buffer.setBufferSize(scrollback);
else
buffer.setBufferSize(0);
resetColors();
buffer.setDisplay(this);
selectionArea = new SelectionArea();
keyListener = new TerminalKeyListener(manager, this, buffer, host.getEncoding());
}
public PromptHelper getPromptHelper() {
return promptHelper;
}
/**
* Spawn thread to open connection and start login process.
*/
protected void startConnection() {
transport = TransportFactory.getTransport(host.getProtocol());
transport.setBridge(this);
transport.setManager(manager);
transport.setHost(host);
// TODO make this more abstract so we don't litter on AbsTransport
transport.setCompression(host.getCompression());
transport.setUseAuthAgent(host.getUseAuthAgent());
transport.setEmulation(emulation);
if (transport.canForwardPorts()) {
for (PortForwardBean portForward : manager.hostdb.getPortForwardsForHost(host))
transport.addPortForward(portForward);
}
outputLine(manager.res.getString(R.string.terminal_connecting, host.getHostname(), host.getPort(), host.getProtocol()));
Thread connectionThread = new Thread(new Runnable() {
public void run() {
transport.connect();
}
});
connectionThread.setName("Connection");
connectionThread.setDaemon(true);
connectionThread.start();
}
/**
* Handle challenges from keyboard-interactive authentication mode.
*/
public String[] replyToChallenge(String name, String instruction, int numPrompts, String[] prompt, boolean[] echo) {
String[] responses = new String[numPrompts];
for(int i = 0; i < numPrompts; i++) {
// request response from user for each prompt
responses[i] = promptHelper.requestStringPrompt(instruction, prompt[i]);
}
return responses;
}
/**
* @return charset in use by bridge
*/
public Charset getCharset() {
return relay.getCharset();
}
/**
* Sets the encoding used by the terminal. If the connection is live,
* then the character set is changed for the next read.
* @param encoding the canonical name of the character encoding
*/
public void setCharset(String encoding) {
if (relay != null)
relay.setCharset(encoding);
keyListener.setCharset(encoding);
}
/**
* Convenience method for writing a line into the underlying MUD buffer.
* Should never be called once the session is established.
*/
public final void outputLine(String line) {
if (transport != null && transport.isSessionOpen())
Log.e(TAG, "Session established, cannot use outputLine!", new IOException("outputLine call traceback"));
synchronized (localOutput) {
final String s = line + "\r\n";
localOutput.add(s);
((vt320) buffer).putString(s);
// For accessibility
final char[] charArray = s.toCharArray();
propagateConsoleText(charArray, charArray.length);
}
}
/**
* Inject a specific string into this terminal. Used for post-login strings
* and pasting clipboard.
*/
public void injectString(final String string) {
if (string == null || string.length() == 0)
return;
Thread injectStringThread = new Thread(new Runnable() {
public void run() {
try {
transport.write(string.getBytes(host.getEncoding()));
} catch (Exception e) {
Log.e(TAG, "Couldn't inject string to remote host: ", e);
}
}
});
injectStringThread.setName("InjectString");
injectStringThread.start();
}
/**
* Internal method to request actual PTY terminal once we've finished
* authentication. If called before authenticated, it will just fail.
*/
public void onConnected() {
disconnected = false;
((vt320) buffer).reset();
// We no longer need our local output.
localOutput.clear();
// previously tried vt100 and xterm for emulation modes
// "screen" works the best for color and escape codes
((vt320) buffer).setAnswerBack(emulation);
if (HostDatabase.DELKEY_BACKSPACE.equals(host.getDelKey()))
((vt320) buffer).setBackspace(vt320.DELETE_IS_BACKSPACE);
else
((vt320) buffer).setBackspace(vt320.DELETE_IS_DEL);
// create thread to relay incoming connection data to buffer
relay = new Relay(this, transport, (vt320) buffer, host.getEncoding());
Thread relayThread = new Thread(relay);
relayThread.setDaemon(true);
relayThread.setName("Relay");
relayThread.start();
// force font-size to make sure we resizePTY as needed
setFontSize(fontSize);
// finally send any post-login string, if requested
injectString(host.getPostLogin());
}
/**
* @return whether a session is open or not
*/
public boolean isSessionOpen() {
if (transport != null)
return transport.isSessionOpen();
return false;
}
public void setOnDisconnectedListener(BridgeDisconnectedListener disconnectListener) {
this.disconnectListener = disconnectListener;
}
/**
* Force disconnection of this terminal bridge.
*/
public void dispatchDisconnect(boolean immediate) {
// We don't need to do this multiple times.
synchronized (this) {
if (disconnected && !immediate)
return;
disconnected = true;
}
// Cancel any pending prompts.
promptHelper.cancelPrompt();
// disconnection request hangs if we havent really connected to a host yet
// temporary fix is to just spawn disconnection into a thread
Thread disconnectThread = new Thread(new Runnable() {
public void run() {
if (transport != null && transport.isConnected())
transport.close();
}
});
disconnectThread.setName("Disconnect");
disconnectThread.start();
if (immediate) {
awaitingClose = true;
if (disconnectListener != null)
disconnectListener.onDisconnected(TerminalBridge.this);
} else {
{
final String line = manager.res.getString(R.string.alert_disconnect_msg);
((vt320) buffer).putString("\r\n" + line + "\r\n");
}
if (host.getStayConnected()) {
manager.requestReconnect(this);
return;
}
Thread disconnectPromptThread = new Thread(new Runnable() {
public void run() {
Boolean result = promptHelper.requestBooleanPrompt(null,
manager.res.getString(R.string.prompt_host_disconnected));
if (result == null || result.booleanValue()) {
awaitingClose = true;
// Tell the TerminalManager that we can be destroyed now.
if (disconnectListener != null)
disconnectListener.onDisconnected(TerminalBridge.this);
}
}
});
disconnectPromptThread.setName("DisconnectPrompt");
disconnectPromptThread.setDaemon(true);
disconnectPromptThread.start();
}
}
public void setSelectingForCopy(boolean selectingForCopy) {
this.selectingForCopy = selectingForCopy;
}
public boolean isSelectingForCopy() {
return selectingForCopy;
}
public SelectionArea getSelectionArea() {
return selectionArea;
}
public synchronized void tryKeyVibrate() {
manager.tryKeyVibrate();
}
/**
* Request a different font size. Will make call to parentChanged() to make
* sure we resize PTY if needed.
*/
/* package */ final void setFontSize(float size) {
if (size <= 0.0)
return;
defaultPaint.setTextSize(size);
fontSize = size;
// read new metrics to get exact pixel dimensions
FontMetrics fm = defaultPaint.getFontMetrics();
charTop = (int)Math.ceil(fm.top);
float[] widths = new float[1];
defaultPaint.getTextWidths("X", widths);
charWidth = (int)Math.ceil(widths[0]);
charHeight = (int)Math.ceil(fm.descent - fm.top);
// refresh any bitmap with new font size
if(parent != null)
parentChanged(parent);
for (FontSizeChangedListener ofscl : fontSizeChangedListeners)
ofscl.onFontSizeChanged(size);
host.setFontSize((int) fontSize);
manager.hostdb.updateFontSize(host);
forcedSize = false;
}
/**
* Add an {@link FontSizeChangedListener} to the list of listeners for this
* bridge.
*
* @param listener
* listener to add
*/
public void addFontSizeChangedListener(FontSizeChangedListener listener) {
fontSizeChangedListeners.add(listener);
}
/**
* Remove an {@link FontSizeChangedListener} from the list of listeners for
* this bridge.
*
* @param listener
*/
public void removeFontSizeChangedListener(FontSizeChangedListener listener) {
fontSizeChangedListeners.remove(listener);
}
/**
* Something changed in our parent {@link TerminalView}, maybe it's a new
* parent, or maybe it's an updated font size. We should recalculate
* terminal size information and request a PTY resize.
*/
public final synchronized void parentChanged(TerminalView parent) {
if (manager != null && !manager.isResizeAllowed()) {
Log.d(TAG, "Resize is not allowed now");
return;
}
this.parent = parent;
final int width = parent.getWidth();
final int height = parent.getHeight();
// Something has gone wrong with our layout; we're 0 width or height!
if (width <= 0 || height <= 0)
return;
clipboard = (ClipboardManager) parent.getContext().getSystemService(Context.CLIPBOARD_SERVICE);
keyListener.setClipboardManager(clipboard);
if (!forcedSize) {
// recalculate buffer size
int newColumns, newRows;
newColumns = width / charWidth;
newRows = height / charHeight;
// If nothing has changed in the terminal dimensions and not an intial
// draw then don't blow away scroll regions and such.
if (newColumns == columns && newRows == rows)
return;
columns = newColumns;
rows = newRows;
}
// reallocate new bitmap if needed
boolean newBitmap = (bitmap == null);
if(bitmap != null)
newBitmap = (bitmap.getWidth() != width || bitmap.getHeight() != height);
if (newBitmap) {
discardBitmap();
bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
canvas.setBitmap(bitmap);
}
// clear out any old buffer information
defaultPaint.setColor(Color.BLACK);
canvas.drawPaint(defaultPaint);
// Stroke the border of the terminal if the size is being forced;
if (forcedSize) {
int borderX = (columns * charWidth) + 1;
int borderY = (rows * charHeight) + 1;
defaultPaint.setColor(Color.GRAY);
defaultPaint.setStrokeWidth(0.0f);
if (width >= borderX)
canvas.drawLine(borderX, 0, borderX, borderY + 1, defaultPaint);
if (height >= borderY)
canvas.drawLine(0, borderY, borderX + 1, borderY, defaultPaint);
}
try {
// request a terminal pty resize
synchronized (buffer) {
buffer.setScreenSize(columns, rows, true);
}
if(transport != null)
transport.setDimensions(columns, rows, width, height);
} catch(Exception e) {
Log.e(TAG, "Problem while trying to resize screen or PTY", e);
}
// redraw local output if we don't have a sesson to receive our resize request
if (transport == null) {
synchronized (localOutput) {
((vt320) buffer).reset();
for (String line : localOutput)
((vt320) buffer).putString(line);
}
}
// force full redraw with new buffer size
fullRedraw = true;
redraw();
parent.notifyUser(String.format("%d x %d", columns, rows));
Log.i(TAG, String.format("parentChanged() now width=%d, height=%d", columns, rows));
}
/**
* Somehow our parent {@link TerminalView} was destroyed. Now we don't need
* to redraw anywhere, and we can recycle our internal bitmap.
*/
public synchronized void parentDestroyed() {
parent = null;
discardBitmap();
}
private void discardBitmap() {
if (bitmap != null)
bitmap.recycle();
bitmap = null;
}
public void setVDUBuffer(VDUBuffer buffer) {
this.buffer = buffer;
}
public VDUBuffer getVDUBuffer() {
return buffer;
}
public void propagateConsoleText(char[] rawText, int length) {
if (parent != null) {
parent.propagateConsoleText(rawText, length);
}
}
public void onDraw() {
int fg, bg;
synchronized (buffer) {
boolean entireDirty = buffer.update[0] || fullRedraw;
boolean isWideCharacter = false;
// walk through all lines in the buffer
for(int l = 0; l < buffer.height; l++) {
// check if this line is dirty and needs to be repainted
// also check for entire-buffer dirty flags
if (!entireDirty && !buffer.update[l + 1]) continue;
// reset dirty flag for this line
buffer.update[l + 1] = false;
// walk through all characters in this line
for (int c = 0; c < buffer.width; c++) {
int addr = 0;
int currAttr = buffer.charAttributes[buffer.windowBase + l][c];
{
int fgcolor = defaultFg;
// check if foreground color attribute is set
if ((currAttr & VDUBuffer.COLOR_FG) != 0)
fgcolor = ((currAttr & VDUBuffer.COLOR_FG) >> VDUBuffer.COLOR_FG_SHIFT) - 1;
if (fgcolor < 8 && (currAttr & VDUBuffer.BOLD) != 0)
fg = color[fgcolor + 8];
else
fg = color[fgcolor];
}
// check if background color attribute is set
if ((currAttr & VDUBuffer.COLOR_BG) != 0)
bg = color[((currAttr & VDUBuffer.COLOR_BG) >> VDUBuffer.COLOR_BG_SHIFT) - 1];
else
bg = color[defaultBg];
// support character inversion by swapping background and foreground color
if ((currAttr & VDUBuffer.INVERT) != 0) {
int swapc = bg;
bg = fg;
fg = swapc;
}
// set underlined attributes if requested
defaultPaint.setUnderlineText((currAttr & VDUBuffer.UNDERLINE) != 0);
isWideCharacter = (currAttr & VDUBuffer.FULLWIDTH) != 0;
if (isWideCharacter)
addr++;
else {
// determine the amount of continuous characters with the same settings and print them all at once
while(c + addr < buffer.width
&& buffer.charAttributes[buffer.windowBase + l][c + addr] == currAttr) {
addr++;
}
}
// Save the current clip region
canvas.save(Canvas.CLIP_SAVE_FLAG);
// clear this dirty area with background color
defaultPaint.setColor(bg);
if (isWideCharacter) {
canvas.clipRect(c * charWidth,
l * charHeight,
(c + 2) * charWidth,
(l + 1) * charHeight);
} else {
canvas.clipRect(c * charWidth,
l * charHeight,
(c + addr) * charWidth,
(l + 1) * charHeight);
}
canvas.drawPaint(defaultPaint);
// write the text string starting at 'c' for 'addr' number of characters
defaultPaint.setColor(fg);
if((currAttr & VDUBuffer.INVISIBLE) == 0)
canvas.drawText(buffer.charArray[buffer.windowBase + l], c,
addr, c * charWidth, (l * charHeight) - charTop,
defaultPaint);
// Restore the previous clip region
canvas.restore();
// advance to the next text block with different characteristics
c += addr - 1;
if (isWideCharacter)
c++;
}
}
// reset entire-buffer flags
buffer.update[0] = false;
}
fullRedraw = false;
}
public void redraw() {
if (parent != null)
parent.postInvalidate();
}
// We don't have a scroll bar.
public void updateScrollBar() {
}
/**
* Resize terminal to fit [rows]x[cols] in screen of size [width]x[height]
* @param rows
* @param cols
* @param width
* @param height
*/
public synchronized void resizeComputed(int cols, int rows, int width, int height) {
float size = 8.0f;
float step = 8.0f;
float limit = 0.125f;
int direction;
while ((direction = fontSizeCompare(size, cols, rows, width, height)) < 0)
size += step;
if (direction == 0) {
Log.d("fontsize", String.format("Found match at %f", size));
return;
}
step /= 2.0f;
size -= step;
while ((direction = fontSizeCompare(size, cols, rows, width, height)) != 0
&& step >= limit) {
step /= 2.0f;
if (direction > 0) {
size -= step;
} else {
size += step;
}
}
if (direction > 0)
size -= step;
this.columns = cols;
this.rows = rows;
setFontSize(size);
forcedSize = true;
}
private int fontSizeCompare(float size, int cols, int rows, int width, int height) {
// read new metrics to get exact pixel dimensions
defaultPaint.setTextSize(size);
FontMetrics fm = defaultPaint.getFontMetrics();
float[] widths = new float[1];
defaultPaint.getTextWidths("X", widths);
int termWidth = (int)widths[0] * cols;
int termHeight = (int)Math.ceil(fm.descent - fm.top) * rows;
Log.d("fontsize", String.format("font size %f resulted in %d x %d", size, termWidth, termHeight));
// Check to see if it fits in resolution specified.
if (termWidth > width || termHeight > height)
return 1;
if (termWidth == width || termHeight == height)
return 0;
return -1;
}
/**
* @return whether underlying transport can forward ports
*/
public boolean canFowardPorts() {
return transport.canForwardPorts();
}
/**
* Adds the {@link PortForwardBean} to the list.
* @param portForward the port forward bean to add
* @return true on successful addition
*/
public boolean addPortForward(PortForwardBean portForward) {
return transport.addPortForward(portForward);
}
/**
* Removes the {@link PortForwardBean} from the list.
* @param portForward the port forward bean to remove
* @return true on successful removal
*/
public boolean removePortForward(PortForwardBean portForward) {
return transport.removePortForward(portForward);
}
/**
* @return the list of port forwards
*/
public List<PortForwardBean> getPortForwards() {
return transport.getPortForwards();
}
/**
* Enables a port forward member. After calling this method, the port forward should
* be operational.
* @param portForward member of our current port forwards list to enable
* @return true on successful port forward setup
*/
public boolean enablePortForward(PortForwardBean portForward) {
if (!transport.isConnected()) {
Log.i(TAG, "Attempt to enable port forward while not connected");
return false;
}
return transport.enablePortForward(portForward);
}
/**
* Disables a port forward member. After calling this method, the port forward should
* be non-functioning.
* @param portForward member of our current port forwards list to enable
* @return true on successful port forward tear-down
*/
public boolean disablePortForward(PortForwardBean portForward) {
if (!transport.isConnected()) {
Log.i(TAG, "Attempt to disable port forward while not connected");
return false;
}
return transport.disablePortForward(portForward);
}
/**
* @return whether the TerminalBridge should close
*/
public boolean isAwaitingClose() {
return awaitingClose;
}
/**
* @return whether this connection had started and subsequently disconnected
*/
public boolean isDisconnected() {
return disconnected;
}
/* (non-Javadoc)
* @see de.mud.terminal.VDUDisplay#setColor(byte, byte, byte, byte)
*/
public void setColor(int index, int red, int green, int blue) {
// Don't allow the system colors to be overwritten for now. May violate specs.
if (index < color.length && index >= 16)
color[index] = 0xff000000 | red << 16 | green << 8 | blue;
}
public final void resetColors() {
int[] defaults = manager.hostdb.getDefaultColorsForScheme(HostDatabase.DEFAULT_COLOR_SCHEME);
defaultFg = defaults[0];
defaultBg = defaults[1];
color = manager.hostdb.getColorsForScheme(HostDatabase.DEFAULT_COLOR_SCHEME);
}
private static Pattern urlPattern = null;
/**
* @return
*/
public List<String> scanForURLs() {
List<String> urls = new LinkedList<String>();
if (urlPattern == null) {
// based on http://www.ietf.org/rfc/rfc2396.txt
String scheme = "[A-Za-z][-+.0-9A-Za-z]*";
String unreserved = "[-._~0-9A-Za-z]";
String pctEncoded = "%[0-9A-Fa-f]{2}";
String subDelims = "[!$&'()*+,;:=]";
String userinfo = "(?:" + unreserved + "|" + pctEncoded + "|" + subDelims + "|:)*";
String h16 = "[0-9A-Fa-f]{1,4}";
String decOctet = "(?:[0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])";
String ipv4address = decOctet + "\\." + decOctet + "\\." + decOctet + "\\." + decOctet;
String ls32 = "(?:" + h16 + ":" + h16 + "|" + ipv4address + ")";
String ipv6address = "(?:(?:" + h16 + "){6}" + ls32 + ")";
String ipvfuture = "v[0-9A-Fa-f]+.(?:" + unreserved + "|" + subDelims + "|:)+";
String ipLiteral = "\\[(?:" + ipv6address + "|" + ipvfuture + ")\\]";
String regName = "(?:" + unreserved + "|" + pctEncoded + "|" + subDelims + ")*";
String host = "(?:" + ipLiteral + "|" + ipv4address + "|" + regName + ")";
String port = "[0-9]*";
String authority = "(?:" + userinfo + "@)?" + host + "(?::" + port + ")?";
String pchar = "(?:" + unreserved + "|" + pctEncoded + "|" + subDelims + "|@)";
String segment = pchar + "*";
String pathAbempty = "(?:/" + segment + ")*";
String segmentNz = pchar + "+";
String pathAbsolute = "/(?:" + segmentNz + "(?:/" + segment + ")*)?";
String pathRootless = segmentNz + "(?:/" + segment + ")*";
String hierPart = "(?://" + authority + pathAbempty + "|" + pathAbsolute + "|" + pathRootless + ")";
String query = "(?:" + pchar + "|/|\\?)*";
String fragment = "(?:" + pchar + "|/|\\?)*";
String uriRegex = scheme + ":" + hierPart + "(?:" + query + ")?(?:#" + fragment + ")?";
urlPattern = Pattern.compile(uriRegex);
}
char[] visibleBuffer = new char[buffer.height * buffer.width];
for (int l = 0; l < buffer.height; l++)
System.arraycopy(buffer.charArray[buffer.windowBase + l], 0,
visibleBuffer, l * buffer.width, buffer.width);
Matcher urlMatcher = urlPattern.matcher(new String(visibleBuffer));
while (urlMatcher.find())
urls.add(urlMatcher.group());
return urls;
}
/**
* @return
*/
public boolean isUsingNetwork() {
return transport.usesNetwork();
}
/**
* @return
*/
public TerminalKeyListener getKeyHandler() {
return keyListener;
}
/**
*
*/
public void resetScrollPosition() {
// if we're in scrollback, scroll to bottom of window on input
if (buffer.windowBase != buffer.screenBase)
buffer.setWindowBase(buffer.screenBase);
}
/**
*
*/
public void increaseFontSize() {
setFontSize(fontSize + FONT_SIZE_STEP);
}
/**
*
*/
public void decreaseFontSize() {
setFontSize(fontSize - FONT_SIZE_STEP);
}
}
| Java |
/**
*
*/
package org.connectbot.service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.NetworkInfo.State;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiManager.WifiLock;
import android.util.Log;
/**
* @author kroot
*
*/
public class ConnectivityReceiver extends BroadcastReceiver {
private static final String TAG = "ConnectBot.ConnectivityManager";
private boolean mIsConnected = false;
final private TerminalManager mTerminalManager;
final private WifiLock mWifiLock;
private int mNetworkRef = 0;
private boolean mLockingWifi;
private Object[] mLock = new Object[0];
public ConnectivityReceiver(TerminalManager manager, boolean lockingWifi) {
mTerminalManager = manager;
final ConnectivityManager cm =
(ConnectivityManager) manager.getSystemService(Context.CONNECTIVITY_SERVICE);
final WifiManager wm = (WifiManager) manager.getSystemService(Context.WIFI_SERVICE);
mWifiLock = wm.createWifiLock(TAG);
final NetworkInfo info = cm.getActiveNetworkInfo();
if (info != null) {
mIsConnected = (info.getState() == State.CONNECTED);
}
mLockingWifi = lockingWifi;
final IntentFilter filter = new IntentFilter();
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
manager.registerReceiver(this, filter);
}
/* (non-Javadoc)
* @see android.content.BroadcastReceiver#onReceive(android.content.Context, android.content.Intent)
*/
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
Log.w(TAG, "onReceived() called: " + intent);
return;
}
boolean noConnectivity = intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
boolean isFailover = intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false);
Log.d(TAG, "onReceived() called; noConnectivity? " + noConnectivity + "; isFailover? " + isFailover);
if (noConnectivity && !isFailover && mIsConnected) {
mIsConnected = false;
mTerminalManager.onConnectivityLost();
} else if (!mIsConnected) {
NetworkInfo info = (NetworkInfo) intent.getExtras()
.get(ConnectivityManager.EXTRA_NETWORK_INFO);
if (mIsConnected = (info.getState() == State.CONNECTED)) {
mTerminalManager.onConnectivityRestored();
}
}
}
/**
*
*/
public void cleanup() {
if (mWifiLock.isHeld())
mWifiLock.release();
mTerminalManager.unregisterReceiver(this);
}
/**
* Increase the number of things using the network. Acquire a Wi-Fi lock
* if necessary.
*/
public void incRef() {
synchronized (mLock) {
mNetworkRef += 1;
acquireWifiLockIfNecessaryLocked();
}
}
/**
* Decrease the number of things using the network. Release the Wi-Fi lock
* if necessary.
*/
public void decRef() {
synchronized (mLock) {
mNetworkRef -= 1;
releaseWifiLockIfNecessaryLocked();
}
}
/**
* @param mLockingWifi
*/
public void setWantWifiLock(boolean lockingWifi) {
synchronized (mLock) {
mLockingWifi = lockingWifi;
if (mLockingWifi) {
acquireWifiLockIfNecessaryLocked();
} else {
releaseWifiLockIfNecessaryLocked();
}
}
}
private void acquireWifiLockIfNecessaryLocked() {
if (mLockingWifi && mNetworkRef > 0 && !mWifiLock.isHeld()) {
mWifiLock.acquire();
}
}
private void releaseWifiLockIfNecessaryLocked() {
if (mNetworkRef == 0 && mWifiLock.isHeld()) {
mWifiLock.release();
}
}
/**
* @return whether we're connected to a network
*/
public boolean isConnected() {
return mIsConnected;
}
}
| 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 java.util.List;
import org.connectbot.bean.HostBean;
import org.connectbot.bean.PortForwardBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import org.connectbot.util.HostDatabase;
import android.app.AlertDialog;
import android.app.ListActivity;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.res.Resources;
import android.database.SQLException;
import android.graphics.Paint;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.util.Log;
import android.view.ContextMenu;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.MenuItem.OnMenuItemClickListener;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemSelectedListener;
/**
* List all portForwards for a particular host and provide a way for users to add more portForwards,
* edit existing portForwards, and delete portForwards.
*
* @author Kenny Root
*/
public class PortForwardListActivity extends ListActivity {
public final static String TAG = "ConnectBot.PortForwardListActivity";
private static final int LISTENER_CYCLE_TIME = 500;
protected HostDatabase hostdb;
private List<PortForwardBean> portForwards;
private ServiceConnection connection = null;
protected TerminalBridge hostBridge = null;
protected LayoutInflater inflater = null;
private HostBean host;
@Override
public void onStart() {
super.onStart();
this.bindService(new Intent(this, TerminalManager.class), connection, Context.BIND_AUTO_CREATE);
if(this.hostdb == null)
this.hostdb = new HostDatabase(this);
}
@Override
public void onStop() {
super.onStop();
this.unbindService(connection);
if(this.hostdb != null) {
this.hostdb.close();
this.hostdb = null;
}
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
long hostId = this.getIntent().getLongExtra(Intent.EXTRA_TITLE, -1);
setContentView(R.layout.act_portforwardlist);
// connect with hosts database and populate list
this.hostdb = new HostDatabase(this);
host = hostdb.findHostById(hostId);
{
final String nickname = host != null ? host.getNickname() : null;
final Resources resources = getResources();
if (nickname != null) {
this.setTitle(String.format("%s: %s (%s)",
resources.getText(R.string.app_name),
resources.getText(R.string.title_port_forwards_list),
nickname));
} else {
this.setTitle(String.format("%s: %s",
resources.getText(R.string.app_name),
resources.getText(R.string.title_port_forwards_list)));
}
}
connection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
TerminalManager bound = ((TerminalManager.TerminalBinder) service).getService();
hostBridge = bound.getConnectedBridge(host);
updateHandler.sendEmptyMessage(-1);
}
public void onServiceDisconnected(ComponentName name) {
hostBridge = null;
}
};
this.updateList();
this.registerForContextMenu(this.getListView());
this.getListView().setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> adapter, View view, int position, long id) {
ListView lv = PortForwardListActivity.this.getListView();
PortForwardBean pfb = (PortForwardBean) lv.getItemAtPosition(position);
if (hostBridge != null) {
if (pfb.isEnabled())
hostBridge.disablePortForward(pfb);
else {
if (!hostBridge.enablePortForward(pfb))
Toast.makeText(PortForwardListActivity.this, getString(R.string.portforward_problem), Toast.LENGTH_LONG).show();
}
updateHandler.sendEmptyMessage(-1);
}
}
});
this.inflater = LayoutInflater.from(this);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
MenuItem add = menu.add(R.string.portforward_menu_add);
add.setIcon(android.R.drawable.ic_menu_add);
add.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// build dialog to prompt user about updating
final View portForwardView = inflater.inflate(R.layout.dia_portforward, null, false);
final EditText destEdit = (EditText) portForwardView.findViewById(R.id.portforward_destination);
final Spinner typeSpinner = (Spinner)portForwardView.findViewById(R.id.portforward_type);
typeSpinner.setOnItemSelectedListener(new OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> value, View view,
int position, long id) {
destEdit.setEnabled(position != 2);
}
public void onNothingSelected(AdapterView<?> arg0) {
}
});
new AlertDialog.Builder(PortForwardListActivity.this)
.setView(portForwardView)
.setPositiveButton(R.string.portforward_pos, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
try {
final EditText nicknameEdit = (EditText) portForwardView.findViewById(R.id.nickname);
final EditText sourcePortEdit = (EditText) portForwardView.findViewById(R.id.portforward_source);
String type = HostDatabase.PORTFORWARD_LOCAL;
switch (typeSpinner.getSelectedItemPosition()) {
case 0:
type = HostDatabase.PORTFORWARD_LOCAL;
break;
case 1:
type = HostDatabase.PORTFORWARD_REMOTE;
break;
case 2:
type = HostDatabase.PORTFORWARD_DYNAMIC5;
break;
}
PortForwardBean pfb = new PortForwardBean(
host != null ? host.getId() : -1,
nicknameEdit.getText().toString(), type,
sourcePortEdit.getText().toString(),
destEdit.getText().toString());
if (hostBridge != null) {
hostBridge.addPortForward(pfb);
hostBridge.enablePortForward(pfb);
}
if (host != null && !hostdb.savePortForward(pfb))
throw new SQLException("Could not save port forward");
updateHandler.sendEmptyMessage(-1);
} catch (Exception e) {
Log.e(TAG, "Could not update port forward", e);
// TODO Show failure dialog.
}
}
})
.setNegativeButton(R.string.delete_neg, null).create().show();
return true;
}
});
return true;
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
// Create menu to handle deleting and editing port forward
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo;
final PortForwardBean pfb = (PortForwardBean) this.getListView().getItemAtPosition(info.position);
menu.setHeaderTitle(pfb.getNickname());
MenuItem edit = menu.add(R.string.portforward_edit);
edit.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
final View editTunnelView = inflater.inflate(R.layout.dia_portforward, null, false);
final Spinner typeSpinner = (Spinner) editTunnelView.findViewById(R.id.portforward_type);
if (HostDatabase.PORTFORWARD_LOCAL.equals(pfb.getType()))
typeSpinner.setSelection(0);
else if (HostDatabase.PORTFORWARD_REMOTE.equals(pfb.getType()))
typeSpinner.setSelection(1);
else
typeSpinner.setSelection(2);
final EditText nicknameEdit = (EditText) editTunnelView.findViewById(R.id.nickname);
nicknameEdit.setText(pfb.getNickname());
final EditText sourcePortEdit = (EditText) editTunnelView.findViewById(R.id.portforward_source);
sourcePortEdit.setText(String.valueOf(pfb.getSourcePort()));
final EditText destEdit = (EditText) editTunnelView.findViewById(R.id.portforward_destination);
if (HostDatabase.PORTFORWARD_DYNAMIC5.equals(pfb.getType())) {
destEdit.setEnabled(false);
} else {
destEdit.setText(String.format("%s:%d", pfb.getDestAddr(), pfb.getDestPort()));
}
typeSpinner.setOnItemSelectedListener(new OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> value, View view,
int position, long id) {
destEdit.setEnabled(position != 2);
}
public void onNothingSelected(AdapterView<?> arg0) {
}
});
new AlertDialog.Builder(PortForwardListActivity.this)
.setView(editTunnelView)
.setPositiveButton(R.string.button_change, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
try {
if (hostBridge != null)
hostBridge.disablePortForward(pfb);
pfb.setNickname(nicknameEdit.getText().toString());
switch (typeSpinner.getSelectedItemPosition()) {
case 0:
pfb.setType(HostDatabase.PORTFORWARD_LOCAL);
break;
case 1:
pfb.setType(HostDatabase.PORTFORWARD_REMOTE);
break;
case 2:
pfb.setType(HostDatabase.PORTFORWARD_DYNAMIC5);
break;
}
pfb.setSourcePort(Integer.parseInt(sourcePortEdit.getText().toString()));
pfb.setDest(destEdit.getText().toString());
// Use the new settings for the existing connection.
if (hostBridge != null)
updateHandler.postDelayed(new Runnable() {
public void run() {
hostBridge.enablePortForward(pfb);
updateHandler.sendEmptyMessage(-1);
}
}, LISTENER_CYCLE_TIME);
if (!hostdb.savePortForward(pfb))
throw new SQLException("Could not save port forward");
updateHandler.sendEmptyMessage(-1);
} catch (Exception e) {
Log.e(TAG, "Could not update port forward", e);
// TODO Show failure dialog.
}
}
})
.setNegativeButton(android.R.string.cancel, null).create().show();
return true;
}
});
MenuItem delete = menu.add(R.string.portforward_delete);
delete.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// prompt user to make sure they really want this
new AlertDialog.Builder(PortForwardListActivity.this)
.setMessage(getString(R.string.delete_message, pfb.getNickname()))
.setPositiveButton(R.string.delete_pos, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
try {
// Delete the port forward from the host if needed.
if (hostBridge != null)
hostBridge.removePortForward(pfb);
hostdb.deletePortForward(pfb);
} catch (Exception e) {
Log.e(TAG, "Could not delete port forward", e);
}
updateHandler.sendEmptyMessage(-1);
}
})
.setNegativeButton(R.string.delete_neg, null).create().show();
return true;
}
});
}
protected Handler updateHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
PortForwardListActivity.this.updateList();
}
};
protected void updateList() {
if (hostBridge != null) {
this.portForwards = hostBridge.getPortForwards();
} else {
if (this.hostdb == null) return;
this.portForwards = this.hostdb.getPortForwardsForHost(host);
}
PortForwardAdapter adapter = new PortForwardAdapter(this, portForwards);
this.setListAdapter(adapter);
}
class PortForwardAdapter extends ArrayAdapter<PortForwardBean> {
class ViewHolder {
public TextView nickname;
public TextView caption;
}
private List<PortForwardBean> portForwards;
public PortForwardAdapter(Context context, List<PortForwardBean> portForwards) {
super(context, R.layout.item_portforward, portForwards);
this.portForwards = portForwards;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (convertView == null) {
convertView = inflater.inflate(R.layout.item_portforward, null, false);
holder = new ViewHolder();
holder.nickname = (TextView)convertView.findViewById(android.R.id.text1);
holder.caption = (TextView)convertView.findViewById(android.R.id.text2);
convertView.setTag(holder);
} else
holder = (ViewHolder) convertView.getTag();
PortForwardBean pfb = portForwards.get(position);
holder.nickname.setText(pfb.getNickname());
holder.caption.setText(pfb.getDescription());
if (hostBridge != null && !pfb.isEnabled()) {
holder.nickname.setPaintFlags(holder.nickname.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
holder.caption.setPaintFlags(holder.caption.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
}
return convertView;
}
}
}
| 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.util.PreferenceConstants;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceActivity;
import android.preference.PreferenceManager;
import android.util.Log;
public class SettingsActivity extends PreferenceActivity {
private static final String TAG = "ConnectBot.Settings";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
try {
addPreferencesFromResource(R.xml.preferences);
} catch (ClassCastException e) {
Log.e(TAG, "Shared preferences are corrupt! Resetting to default values.");
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
// Blow away all the preferences
SharedPreferences.Editor editor = preferences.edit();
editor.clear();
editor.commit();
PreferenceManager.setDefaultValues(this, R.xml.preferences, true);
// Since they were able to get to the Settings activity, they already agreed to the EULA
editor = preferences.edit();
editor.putBoolean(PreferenceConstants.EULA, true);
editor.commit();
addPreferencesFromResource(R.xml.preferences);
}
// TODO: add parse checking here to make sure we have integer value for scrollback
}
}
| 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 java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import org.connectbot.bean.PubkeyBean;
import org.connectbot.util.EntropyDialog;
import org.connectbot.util.EntropyView;
import org.connectbot.util.OnEntropyGatheredListener;
import org.connectbot.util.PubkeyDatabase;
import org.connectbot.util.PubkeyUtils;
import android.app.Activity;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnFocusChangeListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.RadioGroup;
import android.widget.SeekBar;
import android.widget.RadioGroup.OnCheckedChangeListener;
import android.widget.SeekBar.OnSeekBarChangeListener;
public class GeneratePubkeyActivity extends Activity implements OnEntropyGatheredListener {
public final static String TAG = "ConnectBot.GeneratePubkeyActivity";
final static int DEFAULT_BITS = 1024;
private LayoutInflater inflater = null;
private EditText nickname;
private RadioGroup keyTypeGroup;
private SeekBar bitsSlider;
private EditText bitsText;
private CheckBox unlockAtStartup;
private CheckBox confirmUse;
private Button save;
private Dialog entropyDialog;
private ProgressDialog progress;
private EditText password1, password2;
private String keyType = PubkeyDatabase.KEY_TYPE_RSA;
private int minBits = 768;
private int bits = DEFAULT_BITS;
private byte[] entropy;
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.act_generatepubkey);
nickname = (EditText) findViewById(R.id.nickname);
keyTypeGroup = (RadioGroup) findViewById(R.id.key_type);
bitsText = (EditText) findViewById(R.id.bits);
bitsSlider = (SeekBar) findViewById(R.id.bits_slider);
password1 = (EditText) findViewById(R.id.password1);
password2 = (EditText) findViewById(R.id.password2);
unlockAtStartup = (CheckBox) findViewById(R.id.unlock_at_startup);
confirmUse = (CheckBox) findViewById(R.id.confirm_use);
save = (Button) findViewById(R.id.save);
inflater = LayoutInflater.from(this);
nickname.addTextChangedListener(textChecker);
password1.addTextChangedListener(textChecker);
password2.addTextChangedListener(textChecker);
keyTypeGroup.setOnCheckedChangeListener(new OnCheckedChangeListener() {
public void onCheckedChanged(RadioGroup group, int checkedId) {
if (checkedId == R.id.rsa) {
minBits = 768;
bitsSlider.setEnabled(true);
bitsSlider.setProgress(DEFAULT_BITS - minBits);
bitsText.setText(String.valueOf(DEFAULT_BITS));
bitsText.setEnabled(true);
keyType = PubkeyDatabase.KEY_TYPE_RSA;
} else if (checkedId == R.id.dsa) {
// DSA keys can only be 1024 bits
bitsSlider.setEnabled(false);
bitsSlider.setProgress(DEFAULT_BITS - minBits);
bitsText.setText(String.valueOf(DEFAULT_BITS));
bitsText.setEnabled(false);
keyType = PubkeyDatabase.KEY_TYPE_DSA;
}
}
});
bitsSlider.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
public void onProgressChanged(SeekBar seekBar, int progress,
boolean fromTouch) {
// Stay evenly divisible by 8 because it looks nicer to have
// 2048 than 2043 bits.
int leftover = progress % 8;
int ourProgress = progress;
if (leftover > 0)
ourProgress += 8 - leftover;
bits = minBits + ourProgress;
bitsText.setText(String.valueOf(bits));
}
public void onStartTrackingTouch(SeekBar seekBar) {
// We don't care about the start.
}
public void onStopTrackingTouch(SeekBar seekBar) {
// We don't care about the stop.
}
});
bitsText.setOnFocusChangeListener(new OnFocusChangeListener() {
public void onFocusChange(View v, boolean hasFocus) {
if (!hasFocus) {
try {
bits = Integer.parseInt(bitsText.getText().toString());
if (bits < minBits) {
bits = minBits;
bitsText.setText(String.valueOf(bits));
}
} catch (NumberFormatException nfe) {
bits = DEFAULT_BITS;
bitsText.setText(String.valueOf(bits));
}
bitsSlider.setProgress(bits - minBits);
}
}
});
save.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
GeneratePubkeyActivity.this.save.setEnabled(false);
GeneratePubkeyActivity.this.startEntropyGather();
}
});
}
private void checkEntries() {
boolean allowSave = true;
if (!password1.getText().toString().equals(password2.getText().toString()))
allowSave = false;
if (nickname.getText().length() == 0)
allowSave = false;
save.setEnabled(allowSave);
}
private void startEntropyGather() {
final View entropyView = inflater.inflate(R.layout.dia_gatherentropy, null, false);
((EntropyView)entropyView.findViewById(R.id.entropy)).addOnEntropyGatheredListener(GeneratePubkeyActivity.this);
entropyDialog = new EntropyDialog(GeneratePubkeyActivity.this, entropyView);
entropyDialog.show();
}
public void onEntropyGathered(byte[] entropy) {
// For some reason the entropy dialog was aborted, exit activity
if (entropy == null) {
finish();
return;
}
this.entropy = entropy.clone();
int numSetBits = 0;
for (int i = 0; i < 20; i++)
numSetBits += measureNumberOfSetBits(this.entropy[i]);
Log.d(TAG, "Entropy distribution=" + (int)(100.0 * numSetBits / 160.0) + "%");
Log.d(TAG, "entropy gathered; attemping to generate key...");
startKeyGen();
}
private void startKeyGen() {
progress = new ProgressDialog(GeneratePubkeyActivity.this);
progress.setMessage(GeneratePubkeyActivity.this.getResources().getText(R.string.pubkey_generating));
progress.setIndeterminate(true);
progress.setCancelable(false);
progress.show();
Thread keyGenThread = new Thread(mKeyGen);
keyGenThread.setName("KeyGen");
keyGenThread.start();
}
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
progress.dismiss();
GeneratePubkeyActivity.this.finish();
}
};
final private Runnable mKeyGen = new Runnable() {
public void run() {
try {
boolean encrypted = false;
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
random.setSeed(entropy);
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(keyType);
keyPairGen.initialize(bits, random);
KeyPair pair = keyPairGen.generateKeyPair();
PrivateKey priv = pair.getPrivate();
PublicKey pub = pair.getPublic();
String secret = password1.getText().toString();
if (secret.length() > 0)
encrypted = true;
Log.d(TAG, "private: " + PubkeyUtils.formatKey(priv));
Log.d(TAG, "public: " + PubkeyUtils.formatKey(pub));
PubkeyBean pubkey = new PubkeyBean();
pubkey.setNickname(nickname.getText().toString());
pubkey.setType(keyType);
pubkey.setPrivateKey(PubkeyUtils.getEncodedPrivate(priv, secret));
pubkey.setPublicKey(PubkeyUtils.getEncodedPublic(pub));
pubkey.setEncrypted(encrypted);
pubkey.setStartup(unlockAtStartup.isChecked());
pubkey.setConfirmUse(confirmUse.isChecked());
PubkeyDatabase pubkeydb = new PubkeyDatabase(GeneratePubkeyActivity.this);
pubkeydb.savePubkey(pubkey);
pubkeydb.close();
} catch (Exception e) {
Log.e(TAG, "Could not generate key pair");
e.printStackTrace();
}
handler.sendEmptyMessage(0);
}
};
final private TextWatcher textChecker = new TextWatcher() {
public void afterTextChanged(Editable s) {}
public void beforeTextChanged(CharSequence s, int start, int count,
int after) {}
public void onTextChanged(CharSequence s, int start, int before,
int count) {
checkEntries();
}
};
private int measureNumberOfSetBits(byte b) {
int numSetBits = 0;
for (int i = 0; i < 8; i++) {
if ((b & 1) == 1)
numSetBits++;
b >>= 1;
}
return numSetBits;
}
}
| 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.bean;
import org.connectbot.util.HostDatabase;
import android.content.ContentValues;
/**
* @author Kenny Root
*
*/
public class PortForwardBean extends AbstractBean {
public static final String BEAN_NAME = "portforward";
/* Database fields */
private long id = -1;
private long hostId = -1;
private String nickname = null;
private String type = null;
private int sourcePort = -1;
private String destAddr = null;
private int destPort = -1;
/* Transient values */
private boolean enabled = false;
private Object identifier = null;
/**
* @param id database ID of port forward
* @param nickname Nickname to use to identify port forward
* @param type One of the port forward types from {@link HostDatabase}
* @param sourcePort Source port number
* @param destAddr Destination hostname or IP address
* @param destPort Destination port number
*/
public PortForwardBean(long id, long hostId, String nickname, String type, int sourcePort, String destAddr, int destPort) {
this.id = id;
this.hostId = hostId;
this.nickname = nickname;
this.type = type;
this.sourcePort = sourcePort;
this.destAddr = destAddr;
this.destPort = destPort;
}
/**
* @param type One of the port forward types from {@link HostDatabase}
* @param source Source port number
* @param dest Destination is "host:port" format
*/
public PortForwardBean(long hostId, String nickname, String type, String source, String dest) {
this.hostId = hostId;
this.nickname = nickname;
this.type = type;
this.sourcePort = Integer.parseInt(source);
setDest(dest);
}
public String getBeanName() {
return BEAN_NAME;
}
/**
* @param id the id to set
*/
public void setId(long id) {
this.id = id;
}
/**
* @return the id
*/
public long getId() {
return id;
}
/**
* @param nickname the nickname to set
*/
public void setNickname(String nickname) {
this.nickname = nickname;
}
/**
* @return the nickname
*/
public String getNickname() {
return nickname;
}
/**
* @param type the type to set
*/
public void setType(String type) {
this.type = type;
}
/**
* @return the type
*/
public String getType() {
return type;
}
/**
* @param sourcePort the sourcePort to set
*/
public void setSourcePort(int sourcePort) {
this.sourcePort = sourcePort;
}
/**
* @return the sourcePort
*/
public int getSourcePort() {
return sourcePort;
}
/**
* @param dest The destination in "host:port" format
*/
public final void setDest(String dest) {
String[] destSplit = dest.split(":");
this.destAddr = destSplit[0];
if (destSplit.length > 1)
this.destPort = Integer.parseInt(destSplit[1]);
}
/**
* @param destAddr the destAddr to set
*/
public void setDestAddr(String destAddr) {
this.destAddr = destAddr;
}
/**
* @return the destAddr
*/
public String getDestAddr() {
return destAddr;
}
/**
* @param destPort the destPort to set
*/
public void setDestPort(int destPort) {
this.destPort = destPort;
}
/**
* @return the destPort
*/
public int getDestPort() {
return destPort;
}
/**
* @param enabled the enabled to set
*/
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
/**
* @return the enabled
*/
public boolean isEnabled() {
return enabled;
}
/**
* @param identifier the identifier of this particular type to set
*/
public void setIdentifier(Object identifier) {
this.identifier = identifier;
}
/**
* @return the identifier used by this particular type
*/
public Object getIdentifier() {
return identifier;
}
/**
* @return human readable description of the port forward
*/
public CharSequence getDescription() {
String description = "Unknown type";
if (HostDatabase.PORTFORWARD_LOCAL.equals(type)) {
description = String.format("Local port %d to %s:%d", sourcePort, destAddr, destPort);
} else if (HostDatabase.PORTFORWARD_REMOTE.equals(type)) {
description = String.format("Remote port %d to %s:%d", sourcePort, destAddr, destPort);
/* I don't think we need the SOCKS4 type.
} else if (HostDatabase.PORTFORWARD_DYNAMIC4.equals(type)) {
description = String.format("Dynamic port %d (SOCKS4)", sourcePort);
*/
} else if (HostDatabase.PORTFORWARD_DYNAMIC5.equals(type)) {
description = String.format("Dynamic port %d (SOCKS)", sourcePort);
}
return description;
}
/**
* @return
*/
public ContentValues getValues() {
ContentValues values = new ContentValues();
values.put(HostDatabase.FIELD_PORTFORWARD_HOSTID, hostId);
values.put(HostDatabase.FIELD_PORTFORWARD_NICKNAME, nickname);
values.put(HostDatabase.FIELD_PORTFORWARD_TYPE, type);
values.put(HostDatabase.FIELD_PORTFORWARD_SOURCEPORT, sourcePort);
values.put(HostDatabase.FIELD_PORTFORWARD_DESTADDR, destAddr);
values.put(HostDatabase.FIELD_PORTFORWARD_DESTPORT, destPort);
return values;
}
}
| 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.bean;
import de.mud.terminal.VDUBuffer;
/**
* @author Kenny Root
* Keep track of a selection area for the terminal copying mechanism.
* If the orientation is flipped one way, swap the bottom and top or
* left and right to keep it in the correct orientation.
*/
public class SelectionArea {
private int top;
private int bottom;
private int left;
private int right;
private int maxColumns;
private int maxRows;
private boolean selectingOrigin;
public SelectionArea() {
reset();
}
public final void reset() {
top = left = bottom = right = 0;
selectingOrigin = true;
}
/**
* @param columns
* @param rows
*/
public void setBounds(int columns, int rows) {
maxColumns = columns - 1;
maxRows = rows - 1;
}
private int checkBounds(int value, int max) {
if (value < 0)
return 0;
else if (value > max)
return max;
else
return value;
}
public boolean isSelectingOrigin() {
return selectingOrigin;
}
public void finishSelectingOrigin() {
selectingOrigin = false;
}
public void decrementRow() {
if (selectingOrigin)
setTop(top - 1);
else
setBottom(bottom - 1);
}
public void incrementRow() {
if (selectingOrigin)
setTop(top + 1);
else
setBottom(bottom + 1);
}
public void setRow(int row) {
if (selectingOrigin)
setTop(row);
else
setBottom(row);
}
private void setTop(int top) {
this.top = bottom = checkBounds(top, maxRows);
}
public int getTop() {
return Math.min(top, bottom);
}
private void setBottom(int bottom) {
this.bottom = checkBounds(bottom, maxRows);
}
public int getBottom() {
return Math.max(top, bottom);
}
public void decrementColumn() {
if (selectingOrigin)
setLeft(left - 1);
else
setRight(right - 1);
}
public void incrementColumn() {
if (selectingOrigin)
setLeft(left + 1);
else
setRight(right + 1);
}
public void setColumn(int column) {
if (selectingOrigin)
setLeft(column);
else
setRight(column);
}
private void setLeft(int left) {
this.left = right = checkBounds(left, maxColumns);
}
public int getLeft() {
return Math.min(left, right);
}
private void setRight(int right) {
this.right = checkBounds(right, maxColumns);
}
public int getRight() {
return Math.max(left, right);
}
public String copyFrom(VDUBuffer vb) {
int size = (getRight() - getLeft() + 1) * (getBottom() - getTop() + 1);
StringBuffer buffer = new StringBuffer(size);
for(int y = getTop(); y <= getBottom(); y++) {
int lastNonSpace = buffer.length();
for (int x = getLeft(); x <= getRight(); x++) {
// only copy printable chars
char c = vb.getChar(x, y);
if (!Character.isDefined(c) ||
(Character.isISOControl(c) && c != '\t'))
c = ' ';
if (c != ' ')
lastNonSpace = buffer.length();
buffer.append(c);
}
// Don't leave a bunch of spaces in our copy buffer.
if (buffer.length() > lastNonSpace)
buffer.delete(lastNonSpace + 1, buffer.length());
if (y != bottom)
buffer.append("\n");
}
return buffer.toString();
}
@Override
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append("SelectionArea[top=");
buffer.append(top);
buffer.append(", bottom=");
buffer.append(bottom);
buffer.append(", left=");
buffer.append(left);
buffer.append(", right=");
buffer.append(right);
buffer.append(", maxColumns=");
buffer.append(maxColumns);
buffer.append(", maxRows=");
buffer.append(maxRows);
buffer.append(", isSelectingOrigin=");
buffer.append(isSelectingOrigin());
buffer.append("]");
return buffer.toString();
}
}
| 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.bean;
import java.util.Map.Entry;
import org.connectbot.util.XmlBuilder;
import android.content.ContentValues;
/**
* @author Kenny Root
*
*/
abstract class AbstractBean {
public abstract ContentValues getValues();
public abstract String getBeanName();
public String toXML() {
XmlBuilder xml = new XmlBuilder();
xml.append(String.format("<%s>", getBeanName()));
ContentValues values = getValues();
for (Entry<String, Object> entry : values.valueSet()) {
Object value = entry.getValue();
if (value != null)
xml.append(entry.getKey(), value);
}
xml.append(String.format("</%s>", getBeanName()));
return xml.toString();
}
}
| 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.bean;
import org.connectbot.util.HostDatabase;
import android.content.ContentValues;
import android.net.Uri;
/**
* @author Kenny Root
*
*/
public class HostBean extends AbstractBean {
public static final String BEAN_NAME = "host";
/* Database fields */
private long id = -1;
private String nickname = null;
private String username = null;
private String hostname = null;
private int port = 22;
private String protocol = "ssh";
private String hostKeyAlgo = null;
private byte[] hostKey = null;
private long lastConnect = -1;
private String color;
private boolean useKeys = true;
private String useAuthAgent = HostDatabase.AUTHAGENT_NO;
private String postLogin = null;
private long pubkeyId = -1;
private boolean wantSession = true;
private String delKey = HostDatabase.DELKEY_DEL;
private int fontSize = -1;
private boolean compression = false;
private String encoding = HostDatabase.ENCODING_DEFAULT;
private boolean stayConnected = false;
public HostBean() {
}
@Override
public String getBeanName() {
return BEAN_NAME;
}
public HostBean(String nickname, String protocol, String username, String hostname, int port) {
this.nickname = nickname;
this.protocol = protocol;
this.username = username;
this.hostname = hostname;
this.port = port;
}
public void setId(long id) {
this.id = id;
}
public long getId() {
return id;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getNickname() {
return nickname;
}
public void setUsername(String username) {
this.username = username;
}
public String getUsername() {
return username;
}
public void setHostname(String hostname) {
this.hostname = hostname;
}
public String getHostname() {
return hostname;
}
public void setPort(int port) {
this.port = port;
}
public int getPort() {
return port;
}
public void setProtocol(String protocol) {
this.protocol = protocol;
}
public String getProtocol() {
return protocol;
}
public void setHostKeyAlgo(String hostKeyAlgo) {
this.hostKeyAlgo = hostKeyAlgo;
}
public String getHostKeyAlgo() {
return hostKeyAlgo;
}
public void setHostKey(byte[] hostKey) {
if (hostKey == null)
this.hostKey = null;
else
this.hostKey = hostKey.clone();
}
public byte[] getHostKey() {
if (hostKey == null)
return null;
else
return hostKey.clone();
}
public void setLastConnect(long lastConnect) {
this.lastConnect = lastConnect;
}
public long getLastConnect() {
return lastConnect;
}
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public void setUseKeys(boolean useKeys) {
this.useKeys = useKeys;
}
public boolean getUseKeys() {
return useKeys;
}
public void setUseAuthAgent(String useAuthAgent) {
this.useAuthAgent = useAuthAgent;
}
public String getUseAuthAgent() {
return useAuthAgent;
}
public void setPostLogin(String postLogin) {
this.postLogin = postLogin;
}
public String getPostLogin() {
return postLogin;
}
public void setPubkeyId(long pubkeyId) {
this.pubkeyId = pubkeyId;
}
public long getPubkeyId() {
return pubkeyId;
}
public void setWantSession(boolean wantSession) {
this.wantSession = wantSession;
}
public boolean getWantSession() {
return wantSession;
}
public void setDelKey(String delKey) {
this.delKey = delKey;
}
public String getDelKey() {
return delKey;
}
public void setFontSize(int fontSize) {
this.fontSize = fontSize;
}
public int getFontSize() {
return fontSize;
}
public void setCompression(boolean compression) {
this.compression = compression;
}
public boolean getCompression() {
return compression;
}
public void setEncoding(String encoding) {
this.encoding = encoding;
}
public String getEncoding() {
return this.encoding;
}
public void setStayConnected(boolean stayConnected) {
this.stayConnected = stayConnected;
}
public boolean getStayConnected() {
return stayConnected;
}
public String getDescription() {
String description = String.format("%s@%s", username, hostname);
if (port != 22)
description += String.format(":%d", port);
return description;
}
@Override
public ContentValues getValues() {
ContentValues values = new ContentValues();
values.put(HostDatabase.FIELD_HOST_NICKNAME, nickname);
values.put(HostDatabase.FIELD_HOST_PROTOCOL, protocol);
values.put(HostDatabase.FIELD_HOST_USERNAME, username);
values.put(HostDatabase.FIELD_HOST_HOSTNAME, hostname);
values.put(HostDatabase.FIELD_HOST_PORT, port);
values.put(HostDatabase.FIELD_HOST_HOSTKEYALGO, hostKeyAlgo);
values.put(HostDatabase.FIELD_HOST_HOSTKEY, hostKey);
values.put(HostDatabase.FIELD_HOST_LASTCONNECT, lastConnect);
values.put(HostDatabase.FIELD_HOST_COLOR, color);
values.put(HostDatabase.FIELD_HOST_USEKEYS, Boolean.toString(useKeys));
values.put(HostDatabase.FIELD_HOST_USEAUTHAGENT, useAuthAgent);
values.put(HostDatabase.FIELD_HOST_POSTLOGIN, postLogin);
values.put(HostDatabase.FIELD_HOST_PUBKEYID, pubkeyId);
values.put(HostDatabase.FIELD_HOST_WANTSESSION, Boolean.toString(wantSession));
values.put(HostDatabase.FIELD_HOST_DELKEY, delKey);
values.put(HostDatabase.FIELD_HOST_FONTSIZE, fontSize);
values.put(HostDatabase.FIELD_HOST_COMPRESSION, Boolean.toString(compression));
values.put(HostDatabase.FIELD_HOST_ENCODING, encoding);
values.put(HostDatabase.FIELD_HOST_STAYCONNECTED, stayConnected);
return values;
}
@Override
public boolean equals(Object o) {
if (o == null || !(o instanceof HostBean))
return false;
HostBean host = (HostBean)o;
if (id != -1 && host.getId() != -1)
return host.getId() == id;
if (nickname == null) {
if (host.getNickname() != null)
return false;
} else if (!nickname.equals(host.getNickname()))
return false;
if (protocol == null) {
if (host.getProtocol() != null)
return false;
} else if (!protocol.equals(host.getProtocol()))
return false;
if (username == null) {
if (host.getUsername() != null)
return false;
} else if (!username.equals(host.getUsername()))
return false;
if (hostname == null) {
if (host.getHostname() != null)
return false;
} else if (!hostname.equals(host.getHostname()))
return false;
if (port != host.getPort())
return false;
return true;
}
@Override
public int hashCode() {
int hash = 7;
if (id != -1)
return (int)id;
hash = 31 * hash + (null == nickname ? 0 : nickname.hashCode());
hash = 31 * hash + (null == protocol ? 0 : protocol.hashCode());
hash = 31 * hash + (null == username ? 0 : username.hashCode());
hash = 31 * hash + (null == hostname ? 0 : hostname.hashCode());
hash = 31 * hash + port;
return hash;
}
/**
* @return URI identifying this HostBean
*/
public Uri getUri() {
StringBuilder sb = new StringBuilder();
sb.append(protocol)
.append("://");
if (username != null)
sb.append(Uri.encode(username))
.append('@');
sb.append(Uri.encode(hostname))
.append(':')
.append(port)
.append("/#")
.append(nickname);
return Uri.parse(sb.toString());
}
}
| 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.bean;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.DSAPublicKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.EncodedKeySpec;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import org.connectbot.util.PubkeyDatabase;
import org.connectbot.util.PubkeyUtils;
import android.content.ContentValues;
/**
* @author Kenny Root
*
*/
public class PubkeyBean extends AbstractBean {
public static final String BEAN_NAME = "pubkey";
private static final String KEY_TYPE_RSA = "RSA";
private static final String KEY_TYPE_DSA = "DSA";
/* Database fields */
private long id;
private String nickname;
private String type;
private byte[] privateKey;
private PublicKey publicKey;
private boolean encrypted = false;
private boolean startup = false;
private boolean confirmUse = false;
private int lifetime = 0;
/* Transient values */
private boolean unlocked = false;
private Object unlockedPrivate = null;
@Override
public String getBeanName() {
return BEAN_NAME;
}
public void setId(long id) {
this.id = id;
}
public long getId() {
return id;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getNickname() {
return nickname;
}
public void setType(String type) {
this.type = type;
}
public String getType() {
return type;
}
public void setPrivateKey(byte[] privateKey) {
if (privateKey == null)
this.privateKey = null;
else
this.privateKey = privateKey.clone();
}
public byte[] getPrivateKey() {
if (privateKey == null)
return null;
else
return privateKey.clone();
}
private PublicKey decodePublicKeyAs(EncodedKeySpec keySpec, String keyType) {
try {
final KeyFactory kf = KeyFactory.getInstance(keyType);
return kf.generatePublic(keySpec);
} catch (NoSuchAlgorithmException e) {
return null;
} catch (InvalidKeySpecException e) {
return null;
}
}
public void setPublicKey(byte[] encoded) {
final X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(encoded);
if (type != null) {
publicKey = decodePublicKeyAs(pubKeySpec, type);
} else {
publicKey = decodePublicKeyAs(pubKeySpec, KEY_TYPE_RSA);
if (publicKey != null) {
type = KEY_TYPE_RSA;
} else {
publicKey = decodePublicKeyAs(pubKeySpec, KEY_TYPE_DSA);
if (publicKey != null) {
type = KEY_TYPE_DSA;
}
}
}
}
public PublicKey getPublicKey() {
return publicKey;
}
public void setEncrypted(boolean encrypted) {
this.encrypted = encrypted;
}
public boolean isEncrypted() {
return encrypted;
}
public void setStartup(boolean startup) {
this.startup = startup;
}
public boolean isStartup() {
return startup;
}
public void setConfirmUse(boolean confirmUse) {
this.confirmUse = confirmUse;
}
public boolean isConfirmUse() {
return confirmUse;
}
public void setLifetime(int lifetime) {
this.lifetime = lifetime;
}
public int getLifetime() {
return lifetime;
}
public void setUnlocked(boolean unlocked) {
this.unlocked = unlocked;
}
public boolean isUnlocked() {
return unlocked;
}
public void setUnlockedPrivate(Object unlockedPrivate) {
this.unlockedPrivate = unlockedPrivate;
}
public Object getUnlockedPrivate() {
return unlockedPrivate;
}
public String getDescription() {
StringBuilder sb = new StringBuilder();
if (publicKey instanceof RSAPublicKey) {
int bits = ((RSAPublicKey) publicKey).getModulus().bitLength();
sb.append("RSA ");
sb.append(bits);
sb.append("-bit");
} else if (publicKey instanceof DSAPublicKey) {
sb.append("DSA 1024-bit");
} else {
sb.append("Unknown Key Type");
}
if (encrypted)
sb.append(" (encrypted)");
return sb.toString();
}
/* (non-Javadoc)
* @see org.connectbot.bean.AbstractBean#getValues()
*/
@Override
public ContentValues getValues() {
ContentValues values = new ContentValues();
values.put(PubkeyDatabase.FIELD_PUBKEY_NICKNAME, nickname);
values.put(PubkeyDatabase.FIELD_PUBKEY_TYPE, type);
values.put(PubkeyDatabase.FIELD_PUBKEY_PRIVATE, privateKey);
values.put(PubkeyDatabase.FIELD_PUBKEY_PUBLIC, publicKey.getEncoded());
values.put(PubkeyDatabase.FIELD_PUBKEY_ENCRYPTED, encrypted ? 1 : 0);
values.put(PubkeyDatabase.FIELD_PUBKEY_STARTUP, startup ? 1 : 0);
values.put(PubkeyDatabase.FIELD_PUBKEY_CONFIRMUSE, confirmUse ? 1 : 0);
values.put(PubkeyDatabase.FIELD_PUBKEY_LIFETIME, lifetime);
return values;
}
public boolean changePassword(String oldPassword, String newPassword) throws Exception {
PrivateKey priv;
try {
priv = PubkeyUtils.decodePrivate(getPrivateKey(), getType(), oldPassword);
} catch (Exception e) {
return false;
}
setPrivateKey(PubkeyUtils.getEncodedPrivate(priv, newPassword));
setEncrypted(newPassword.length() > 0);
return true;
}
}
| 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 java.lang.ref.WeakReference;
import java.util.List;
import org.connectbot.bean.SelectionArea;
import org.connectbot.service.PromptHelper;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalKeyListener;
import org.connectbot.service.TerminalManager;
import org.connectbot.util.PreferenceConstants;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.preference.PreferenceManager;
import android.text.ClipboardManager;
import android.util.Log;
import android.view.GestureDetector;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.WindowManager;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.View.OnClickListener;
import android.view.View.OnKeyListener;
import android.view.View.OnTouchListener;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.ViewFlipper;
import android.widget.AdapterView.OnItemClickListener;
import de.mud.terminal.vt320;
public class ConsoleActivity extends Activity {
public final static String TAG = "ConnectBot.ConsoleActivity";
protected static final int REQUEST_EDIT = 1;
private static final int CLICK_TIME = 400;
private static final float MAX_CLICK_DISTANCE = 25f;
private static final int KEYBOARD_DISPLAY_TIME = 1500;
// Direction to shift the ViewFlipper
private static final int SHIFT_LEFT = 0;
private static final int SHIFT_RIGHT = 1;
protected ViewFlipper flip = null;
protected TerminalManager bound = null;
protected LayoutInflater inflater = null;
private SharedPreferences prefs = null;
// determines whether or not menuitem accelerators are bound
// otherwise they collide with an external keyboard's CTRL-char
private boolean hardKeyboard = false;
protected Uri requested;
protected ClipboardManager clipboard;
private RelativeLayout stringPromptGroup;
protected EditText stringPrompt;
private TextView stringPromptInstructions;
private RelativeLayout booleanPromptGroup;
private TextView booleanPrompt;
private Button booleanYes, booleanNo;
private TextView empty;
private Animation slide_left_in, slide_left_out, slide_right_in, slide_right_out, fade_stay_hidden, fade_out_delayed;
private Animation keyboard_fade_in, keyboard_fade_out;
private float lastX, lastY;
private InputMethodManager inputManager;
private MenuItem disconnect, copy, paste, portForward, resize, urlscan;
protected TerminalBridge copySource = null;
private int lastTouchRow, lastTouchCol;
private boolean forcedOrientation;
private Handler handler = new Handler();
private ImageView mKeyboardButton;
private ServiceConnection connection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
bound = ((TerminalManager.TerminalBinder) service).getService();
// let manager know about our event handling services
bound.disconnectHandler = disconnectHandler;
Log.d(TAG, String.format("Connected to TerminalManager and found bridges.size=%d", bound.bridges.size()));
bound.setResizeAllowed(true);
// clear out any existing bridges and record requested index
flip.removeAllViews();
final String requestedNickname = (requested != null) ? requested.getFragment() : null;
int requestedIndex = 0;
TerminalBridge requestedBridge = bound.getConnectedBridge(requestedNickname);
// If we didn't find the requested connection, try opening it
if (requestedNickname != null && requestedBridge == null) {
try {
Log.d(TAG, String.format("We couldnt find an existing bridge with URI=%s (nickname=%s), so creating one now", requested.toString(), requestedNickname));
requestedBridge = bound.openConnection(requested);
} catch(Exception e) {
Log.e(TAG, "Problem while trying to create new requested bridge from URI", e);
}
}
// create views for all bridges on this service
for (TerminalBridge bridge : bound.bridges) {
final int currentIndex = addNewTerminalView(bridge);
// check to see if this bridge was requested
if (bridge == requestedBridge)
requestedIndex = currentIndex;
}
setDisplayedTerminal(requestedIndex);
}
public void onServiceDisconnected(ComponentName className) {
// tell each bridge to forget about our prompt handler
synchronized (bound.bridges) {
for(TerminalBridge bridge : bound.bridges)
bridge.promptHelper.setHandler(null);
}
flip.removeAllViews();
updateEmptyVisible();
bound = null;
}
};
protected Handler promptHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
// someone below us requested to display a prompt
updatePromptVisible();
}
};
protected Handler disconnectHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
Log.d(TAG, "Someone sending HANDLE_DISCONNECT to parentHandler");
// someone below us requested to display a password dialog
// they are sending nickname and requested
TerminalBridge bridge = (TerminalBridge)msg.obj;
if (bridge.isAwaitingClose())
closeBridge(bridge);
}
};
/**
* @param bridge
*/
private void closeBridge(final TerminalBridge bridge) {
synchronized (flip) {
final int flipIndex = getFlipIndex(bridge);
if (flipIndex >= 0) {
if (flip.getDisplayedChild() == flipIndex) {
shiftCurrentTerminal(SHIFT_LEFT);
}
flip.removeViewAt(flipIndex);
/* TODO Remove this workaround when ViewFlipper is fixed to listen
* to view removals. Android Issue 1784
*/
final int numChildren = flip.getChildCount();
if (flip.getDisplayedChild() >= numChildren &&
numChildren > 0) {
flip.setDisplayedChild(numChildren - 1);
}
updateEmptyVisible();
}
// If we just closed the last bridge, go back to the previous activity.
if (flip.getChildCount() == 0) {
finish();
}
}
}
protected View findCurrentView(int id) {
View view = flip.getCurrentView();
if(view == null) return null;
return view.findViewById(id);
}
protected PromptHelper getCurrentPromptHelper() {
View view = findCurrentView(R.id.console_flip);
if(!(view instanceof TerminalView)) return null;
return ((TerminalView)view).bridge.promptHelper;
}
protected void hideAllPrompts() {
stringPromptGroup.setVisibility(View.GONE);
booleanPromptGroup.setVisibility(View.GONE);
}
// more like configureLaxMode -- enable network IO on UI thread
private void configureStrictMode() {
try {
Class.forName("android.os.StrictMode");
StrictModeSetup.run();
} catch (ClassNotFoundException e) {
}
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
configureStrictMode();
hardKeyboard = getResources().getConfiguration().keyboard ==
Configuration.KEYBOARD_QWERTY;
this.setContentView(R.layout.act_console);
clipboard = (ClipboardManager)getSystemService(CLIPBOARD_SERVICE);
prefs = PreferenceManager.getDefaultSharedPreferences(this);
// hide status bar if requested by user
if (prefs.getBoolean(PreferenceConstants.FULLSCREEN, false)) {
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
// TODO find proper way to disable volume key beep if it exists.
setVolumeControlStream(AudioManager.STREAM_MUSIC);
// handle requested console from incoming intent
requested = getIntent().getData();
inflater = LayoutInflater.from(this);
flip = (ViewFlipper)findViewById(R.id.console_flip);
empty = (TextView)findViewById(android.R.id.empty);
stringPromptGroup = (RelativeLayout) findViewById(R.id.console_password_group);
stringPromptInstructions = (TextView) findViewById(R.id.console_password_instructions);
stringPrompt = (EditText)findViewById(R.id.console_password);
stringPrompt.setOnKeyListener(new OnKeyListener() {
public boolean onKey(View v, int keyCode, KeyEvent event) {
if(event.getAction() == KeyEvent.ACTION_UP) return false;
if(keyCode != KeyEvent.KEYCODE_ENTER) return false;
// pass collected password down to current terminal
String value = stringPrompt.getText().toString();
PromptHelper helper = getCurrentPromptHelper();
if(helper == null) return false;
helper.setResponse(value);
// finally clear password for next user
stringPrompt.setText("");
updatePromptVisible();
return true;
}
});
booleanPromptGroup = (RelativeLayout) findViewById(R.id.console_boolean_group);
booleanPrompt = (TextView)findViewById(R.id.console_prompt);
booleanYes = (Button)findViewById(R.id.console_prompt_yes);
booleanYes.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
PromptHelper helper = getCurrentPromptHelper();
if(helper == null) return;
helper.setResponse(Boolean.TRUE);
updatePromptVisible();
}
});
booleanNo = (Button)findViewById(R.id.console_prompt_no);
booleanNo.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
PromptHelper helper = getCurrentPromptHelper();
if(helper == null) return;
helper.setResponse(Boolean.FALSE);
updatePromptVisible();
}
});
// preload animations for terminal switching
slide_left_in = AnimationUtils.loadAnimation(this, R.anim.slide_left_in);
slide_left_out = AnimationUtils.loadAnimation(this, R.anim.slide_left_out);
slide_right_in = AnimationUtils.loadAnimation(this, R.anim.slide_right_in);
slide_right_out = AnimationUtils.loadAnimation(this, R.anim.slide_right_out);
fade_out_delayed = AnimationUtils.loadAnimation(this, R.anim.fade_out_delayed);
fade_stay_hidden = AnimationUtils.loadAnimation(this, R.anim.fade_stay_hidden);
// Preload animation for keyboard button
keyboard_fade_in = AnimationUtils.loadAnimation(this, R.anim.keyboard_fade_in);
keyboard_fade_out = AnimationUtils.loadAnimation(this, R.anim.keyboard_fade_out);
inputManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
final RelativeLayout keyboardGroup = (RelativeLayout) findViewById(R.id.keyboard_group);
mKeyboardButton = (ImageView) findViewById(R.id.button_keyboard);
mKeyboardButton.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
View flip = findCurrentView(R.id.console_flip);
if (flip == null)
return;
inputManager.showSoftInput(flip, InputMethodManager.SHOW_FORCED);
keyboardGroup.setVisibility(View.GONE);
}
});
final ImageView ctrlButton = (ImageView) findViewById(R.id.button_ctrl);
ctrlButton.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
View flip = findCurrentView(R.id.console_flip);
if (flip == null) return;
TerminalView terminal = (TerminalView)flip;
TerminalKeyListener handler = terminal.bridge.getKeyHandler();
handler.metaPress(TerminalKeyListener.META_CTRL_ON);
keyboardGroup.setVisibility(View.GONE);
}
});
final ImageView escButton = (ImageView) findViewById(R.id.button_esc);
escButton.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
View flip = findCurrentView(R.id.console_flip);
if (flip == null) return;
TerminalView terminal = (TerminalView)flip;
TerminalKeyListener handler = terminal.bridge.getKeyHandler();
handler.sendEscape();
keyboardGroup.setVisibility(View.GONE);
}
});
// detect fling gestures to switch between terminals
final GestureDetector detect = new GestureDetector(new GestureDetector.SimpleOnGestureListener() {
private float totalY = 0;
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
final float distx = e2.getRawX() - e1.getRawX();
final float disty = e2.getRawY() - e1.getRawY();
final int goalwidth = flip.getWidth() / 2;
// need to slide across half of display to trigger console change
// make sure user kept a steady hand horizontally
if (Math.abs(disty) < (flip.getHeight() / 4)) {
if (distx > goalwidth) {
shiftCurrentTerminal(SHIFT_RIGHT);
return true;
}
if (distx < -goalwidth) {
shiftCurrentTerminal(SHIFT_LEFT);
return true;
}
}
return false;
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
// if copying, then ignore
if (copySource != null && copySource.isSelectingForCopy())
return false;
if (e1 == null || e2 == null)
return false;
// if releasing then reset total scroll
if (e2.getAction() == MotionEvent.ACTION_UP) {
totalY = 0;
}
// activate consider if within x tolerance
if (Math.abs(e1.getX() - e2.getX()) < ViewConfiguration.getTouchSlop() * 4) {
View flip = findCurrentView(R.id.console_flip);
if(flip == null) return false;
TerminalView terminal = (TerminalView)flip;
// estimate how many rows we have scrolled through
// accumulate distance that doesn't trigger immediate scroll
totalY += distanceY;
final int moved = (int)(totalY / terminal.bridge.charHeight);
// consume as scrollback only if towards right half of screen
if (e2.getX() > flip.getWidth() / 2) {
if (moved != 0) {
int base = terminal.bridge.buffer.getWindowBase();
terminal.bridge.buffer.setWindowBase(base + moved);
totalY = 0;
return true;
}
} else {
// otherwise consume as pgup/pgdown for every 5 lines
if (moved > 5) {
((vt320)terminal.bridge.buffer).keyPressed(vt320.KEY_PAGE_DOWN, ' ', 0);
terminal.bridge.tryKeyVibrate();
totalY = 0;
return true;
} else if (moved < -5) {
((vt320)terminal.bridge.buffer).keyPressed(vt320.KEY_PAGE_UP, ' ', 0);
terminal.bridge.tryKeyVibrate();
totalY = 0;
return true;
}
}
}
return false;
}
});
flip.setLongClickable(true);
flip.setOnTouchListener(new OnTouchListener() {
public boolean onTouch(View v, MotionEvent event) {
// when copying, highlight the area
if (copySource != null && copySource.isSelectingForCopy()) {
int row = (int)Math.floor(event.getY() / copySource.charHeight);
int col = (int)Math.floor(event.getX() / copySource.charWidth);
SelectionArea area = copySource.getSelectionArea();
switch(event.getAction()) {
case MotionEvent.ACTION_DOWN:
// recording starting area
if (area.isSelectingOrigin()) {
area.setRow(row);
area.setColumn(col);
lastTouchRow = row;
lastTouchCol = col;
copySource.redraw();
}
return true;
case MotionEvent.ACTION_MOVE:
/* ignore when user hasn't moved since last time so
* we can fine-tune with directional pad
*/
if (row == lastTouchRow && col == lastTouchCol)
return true;
// if the user moves, start the selection for other corner
area.finishSelectingOrigin();
// update selected area
area.setRow(row);
area.setColumn(col);
lastTouchRow = row;
lastTouchCol = col;
copySource.redraw();
return true;
case MotionEvent.ACTION_UP:
/* If they didn't move their finger, maybe they meant to
* select the rest of the text with the directional pad.
*/
if (area.getLeft() == area.getRight() &&
area.getTop() == area.getBottom()) {
return true;
}
// copy selected area to clipboard
String copiedText = area.copyFrom(copySource.buffer);
clipboard.setText(copiedText);
Toast.makeText(ConsoleActivity.this, getString(R.string.console_copy_done, copiedText.length()), Toast.LENGTH_LONG).show();
// fall through to clear state
case MotionEvent.ACTION_CANCEL:
// make sure we clear any highlighted area
area.reset();
copySource.setSelectingForCopy(false);
copySource.redraw();
return true;
}
}
Configuration config = getResources().getConfiguration();
if (event.getAction() == MotionEvent.ACTION_DOWN) {
lastX = event.getX();
lastY = event.getY();
} else if (event.getAction() == MotionEvent.ACTION_UP
&& keyboardGroup.getVisibility() == View.GONE
&& event.getEventTime() - event.getDownTime() < CLICK_TIME
&& Math.abs(event.getX() - lastX) < MAX_CLICK_DISTANCE
&& Math.abs(event.getY() - lastY) < MAX_CLICK_DISTANCE) {
keyboardGroup.startAnimation(keyboard_fade_in);
keyboardGroup.setVisibility(View.VISIBLE);
handler.postDelayed(new Runnable() {
public void run() {
if (keyboardGroup.getVisibility() == View.GONE)
return;
keyboardGroup.startAnimation(keyboard_fade_out);
keyboardGroup.setVisibility(View.GONE);
}
}, KEYBOARD_DISPLAY_TIME);
}
// pass any touch events back to detector
return detect.onTouchEvent(event);
}
});
}
/**
*
*/
private void configureOrientation() {
String rotateDefault;
if (getResources().getConfiguration().keyboard == Configuration.KEYBOARD_NOKEYS)
rotateDefault = PreferenceConstants.ROTATION_PORTRAIT;
else
rotateDefault = PreferenceConstants.ROTATION_LANDSCAPE;
String rotate = prefs.getString(PreferenceConstants.ROTATION, rotateDefault);
if (PreferenceConstants.ROTATION_DEFAULT.equals(rotate))
rotate = rotateDefault;
// request a forced orientation if requested by user
if (PreferenceConstants.ROTATION_LANDSCAPE.equals(rotate)) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
forcedOrientation = true;
} else if (PreferenceConstants.ROTATION_PORTRAIT.equals(rotate)) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
forcedOrientation = true;
} else {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
forcedOrientation = false;
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
View view = findCurrentView(R.id.console_flip);
final boolean activeTerminal = (view instanceof TerminalView);
boolean sessionOpen = false;
boolean disconnected = false;
boolean canForwardPorts = false;
if (activeTerminal) {
TerminalBridge bridge = ((TerminalView) view).bridge;
sessionOpen = bridge.isSessionOpen();
disconnected = bridge.isDisconnected();
canForwardPorts = bridge.canFowardPorts();
}
menu.setQwertyMode(true);
disconnect = menu.add(R.string.list_host_disconnect);
if (hardKeyboard)
disconnect.setAlphabeticShortcut('w');
if (!sessionOpen && disconnected)
disconnect.setTitle(R.string.console_menu_close);
disconnect.setEnabled(activeTerminal);
disconnect.setIcon(android.R.drawable.ic_menu_close_clear_cancel);
disconnect.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// disconnect or close the currently visible session
TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
TerminalBridge bridge = terminalView.bridge;
bridge.dispatchDisconnect(true);
return true;
}
});
copy = menu.add(R.string.console_menu_copy);
if (hardKeyboard)
copy.setAlphabeticShortcut('c');
copy.setIcon(android.R.drawable.ic_menu_set_as);
copy.setEnabled(activeTerminal);
copy.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// mark as copying and reset any previous bounds
TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
copySource = terminalView.bridge;
SelectionArea area = copySource.getSelectionArea();
area.reset();
area.setBounds(copySource.buffer.getColumns(), copySource.buffer.getRows());
copySource.setSelectingForCopy(true);
// Make sure we show the initial selection
copySource.redraw();
Toast.makeText(ConsoleActivity.this, getString(R.string.console_copy_start), Toast.LENGTH_LONG).show();
return true;
}
});
paste = menu.add(R.string.console_menu_paste);
if (hardKeyboard)
paste.setAlphabeticShortcut('v');
paste.setIcon(android.R.drawable.ic_menu_edit);
paste.setEnabled(clipboard.hasText() && sessionOpen);
paste.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// force insert of clipboard text into current console
TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
TerminalBridge bridge = terminalView.bridge;
// pull string from clipboard and generate all events to force down
String clip = clipboard.getText().toString();
bridge.injectString(clip);
return true;
}
});
portForward = menu.add(R.string.console_menu_portforwards);
if (hardKeyboard)
portForward.setAlphabeticShortcut('f');
portForward.setIcon(android.R.drawable.ic_menu_manage);
portForward.setEnabled(sessionOpen && canForwardPorts);
portForward.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
TerminalBridge bridge = terminalView.bridge;
Intent intent = new Intent(ConsoleActivity.this, PortForwardListActivity.class);
intent.putExtra(Intent.EXTRA_TITLE, bridge.host.getId());
ConsoleActivity.this.startActivityForResult(intent, REQUEST_EDIT);
return true;
}
});
urlscan = menu.add(R.string.console_menu_urlscan);
if (hardKeyboard)
urlscan.setAlphabeticShortcut('u');
urlscan.setIcon(android.R.drawable.ic_menu_search);
urlscan.setEnabled(activeTerminal);
urlscan.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
final TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
List<String> urls = terminalView.bridge.scanForURLs();
Dialog urlDialog = new Dialog(ConsoleActivity.this);
urlDialog.setTitle(R.string.console_menu_urlscan);
ListView urlListView = new ListView(ConsoleActivity.this);
URLItemListener urlListener = new URLItemListener(ConsoleActivity.this);
urlListView.setOnItemClickListener(urlListener);
urlListView.setAdapter(new ArrayAdapter<String>(ConsoleActivity.this, android.R.layout.simple_list_item_1, urls));
urlDialog.setContentView(urlListView);
urlDialog.show();
return true;
}
});
resize = menu.add(R.string.console_menu_resize);
if (hardKeyboard)
resize.setAlphabeticShortcut('s');
resize.setIcon(android.R.drawable.ic_menu_crop);
resize.setEnabled(sessionOpen);
resize.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
final TerminalView terminalView = (TerminalView) findCurrentView(R.id.console_flip);
final View resizeView = inflater.inflate(R.layout.dia_resize, null, false);
new AlertDialog.Builder(ConsoleActivity.this)
.setView(resizeView)
.setPositiveButton(R.string.button_resize, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
int width, height;
try {
width = Integer.parseInt(((EditText) resizeView
.findViewById(R.id.width))
.getText().toString());
height = Integer.parseInt(((EditText) resizeView
.findViewById(R.id.height))
.getText().toString());
} catch (NumberFormatException nfe) {
// TODO change this to a real dialog where we can
// make the input boxes turn red to indicate an error.
return;
}
terminalView.forceSize(width, height);
}
}).setNegativeButton(android.R.string.cancel, null).create().show();
return true;
}
});
return true;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
setVolumeControlStream(AudioManager.STREAM_NOTIFICATION);
final View view = findCurrentView(R.id.console_flip);
boolean activeTerminal = (view instanceof TerminalView);
boolean sessionOpen = false;
boolean disconnected = false;
boolean canForwardPorts = false;
if (activeTerminal) {
TerminalBridge bridge = ((TerminalView) view).bridge;
sessionOpen = bridge.isSessionOpen();
disconnected = bridge.isDisconnected();
canForwardPorts = bridge.canFowardPorts();
}
disconnect.setEnabled(activeTerminal);
if (sessionOpen || !disconnected)
disconnect.setTitle(R.string.list_host_disconnect);
else
disconnect.setTitle(R.string.console_menu_close);
copy.setEnabled(activeTerminal);
paste.setEnabled(clipboard.hasText() && sessionOpen);
portForward.setEnabled(sessionOpen && canForwardPorts);
urlscan.setEnabled(activeTerminal);
resize.setEnabled(sessionOpen);
return true;
}
@Override
public void onOptionsMenuClosed(Menu menu) {
super.onOptionsMenuClosed(menu);
setVolumeControlStream(AudioManager.STREAM_MUSIC);
}
@Override
public void onStart() {
super.onStart();
// connect with manager service to find all bridges
// when connected it will insert all views
bindService(new Intent(this, TerminalManager.class), connection, Context.BIND_AUTO_CREATE);
}
@Override
public void onPause() {
super.onPause();
Log.d(TAG, "onPause called");
if (forcedOrientation && bound != null)
bound.setResizeAllowed(false);
}
@Override
public void onResume() {
super.onResume();
Log.d(TAG, "onResume called");
// Make sure we don't let the screen fall asleep.
// This also keeps the Wi-Fi chipset from disconnecting us.
if (prefs.getBoolean(PreferenceConstants.KEEP_ALIVE, true)) {
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
} else {
getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
}
configureOrientation();
if (forcedOrientation && bound != null)
bound.setResizeAllowed(true);
}
/* (non-Javadoc)
* @see android.app.Activity#onNewIntent(android.content.Intent)
*/
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
Log.d(TAG, "onNewIntent called");
requested = intent.getData();
if (requested == null) {
Log.e(TAG, "Got null intent data in onNewIntent()");
return;
}
if (bound == null) {
Log.e(TAG, "We're not bound in onNewIntent()");
return;
}
TerminalBridge requestedBridge = bound.getConnectedBridge(requested.getFragment());
int requestedIndex = 0;
synchronized (flip) {
if (requestedBridge == null) {
// If we didn't find the requested connection, try opening it
try {
Log.d(TAG, String.format("We couldnt find an existing bridge with URI=%s (nickname=%s),"+
"so creating one now", requested.toString(), requested.getFragment()));
requestedBridge = bound.openConnection(requested);
} catch(Exception e) {
Log.e(TAG, "Problem while trying to create new requested bridge from URI", e);
// TODO: We should display an error dialog here.
return;
}
requestedIndex = addNewTerminalView(requestedBridge);
} else {
final int flipIndex = getFlipIndex(requestedBridge);
if (flipIndex > requestedIndex) {
requestedIndex = flipIndex;
}
}
setDisplayedTerminal(requestedIndex);
}
}
@Override
public void onStop() {
super.onStop();
unbindService(connection);
}
protected void shiftCurrentTerminal(final int direction) {
View overlay;
synchronized (flip) {
boolean shouldAnimate = flip.getChildCount() > 1;
// Only show animation if there is something else to go to.
if (shouldAnimate) {
// keep current overlay from popping up again
overlay = findCurrentView(R.id.terminal_overlay);
if (overlay != null)
overlay.startAnimation(fade_stay_hidden);
if (direction == SHIFT_LEFT) {
flip.setInAnimation(slide_left_in);
flip.setOutAnimation(slide_left_out);
flip.showNext();
} else if (direction == SHIFT_RIGHT) {
flip.setInAnimation(slide_right_in);
flip.setOutAnimation(slide_right_out);
flip.showPrevious();
}
}
ConsoleActivity.this.updateDefault();
if (shouldAnimate) {
// show overlay on new slide and start fade
overlay = findCurrentView(R.id.terminal_overlay);
if (overlay != null)
overlay.startAnimation(fade_out_delayed);
}
updatePromptVisible();
}
}
/**
* Save the currently shown {@link TerminalView} as the default. This is
* saved back down into {@link TerminalManager} where we can read it again
* later.
*/
private void updateDefault() {
// update the current default terminal
View view = findCurrentView(R.id.console_flip);
if(!(view instanceof TerminalView)) return;
TerminalView terminal = (TerminalView)view;
if(bound == null) return;
bound.defaultBridge = terminal.bridge;
}
protected void updateEmptyVisible() {
// update visibility of empty status message
empty.setVisibility((flip.getChildCount() == 0) ? View.VISIBLE : View.GONE);
}
/**
* Show any prompts requested by the currently visible {@link TerminalView}.
*/
protected void updatePromptVisible() {
// check if our currently-visible terminalbridge is requesting any prompt services
View view = findCurrentView(R.id.console_flip);
// Hide all the prompts in case a prompt request was canceled
hideAllPrompts();
if(!(view instanceof TerminalView)) {
// we dont have an active view, so hide any prompts
return;
}
PromptHelper prompt = ((TerminalView)view).bridge.promptHelper;
if(String.class.equals(prompt.promptRequested)) {
stringPromptGroup.setVisibility(View.VISIBLE);
String instructions = prompt.promptInstructions;
if (instructions != null && instructions.length() > 0) {
stringPromptInstructions.setVisibility(View.VISIBLE);
stringPromptInstructions.setText(instructions);
} else
stringPromptInstructions.setVisibility(View.GONE);
stringPrompt.setText("");
stringPrompt.setHint(prompt.promptHint);
stringPrompt.requestFocus();
} else if(Boolean.class.equals(prompt.promptRequested)) {
booleanPromptGroup.setVisibility(View.VISIBLE);
booleanPrompt.setText(prompt.promptHint);
booleanYes.requestFocus();
} else {
hideAllPrompts();
view.requestFocus();
}
}
private class URLItemListener implements OnItemClickListener {
private WeakReference<Context> contextRef;
URLItemListener(Context context) {
this.contextRef = new WeakReference<Context>(context);
}
public void onItemClick(AdapterView<?> arg0, View view, int position, long id) {
Context context = contextRef.get();
if (context == null)
return;
try {
TextView urlView = (TextView) view;
String url = urlView.getText().toString();
if (url.indexOf("://") < 0)
url = "http://" + url;
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
context.startActivity(intent);
} catch (Exception e) {
Log.e(TAG, "couldn't open URL", e);
// We should probably tell the user that we couldn't find a handler...
}
}
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
Log.d(TAG, String.format("onConfigurationChanged; requestedOrientation=%d, newConfig.orientation=%d", getRequestedOrientation(), newConfig.orientation));
if (bound != null) {
if (forcedOrientation &&
(newConfig.orientation != Configuration.ORIENTATION_LANDSCAPE &&
getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) ||
(newConfig.orientation != Configuration.ORIENTATION_PORTRAIT &&
getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT))
bound.setResizeAllowed(false);
else
bound.setResizeAllowed(true);
bound.hardKeyboardHidden = (newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES);
mKeyboardButton.setVisibility(bound.hardKeyboardHidden ? View.VISIBLE : View.GONE);
}
}
/**
* Adds a new TerminalBridge to the current set of views in our ViewFlipper.
*
* @param bridge TerminalBridge to add to our ViewFlipper
* @return the child index of the new view in the ViewFlipper
*/
private int addNewTerminalView(TerminalBridge bridge) {
// let them know about our prompt handler services
bridge.promptHelper.setHandler(promptHandler);
// inflate each terminal view
RelativeLayout view = (RelativeLayout)inflater.inflate(R.layout.item_terminal, flip, false);
// set the terminal overlay text
TextView overlay = (TextView)view.findViewById(R.id.terminal_overlay);
overlay.setText(bridge.host.getNickname());
// and add our terminal view control, using index to place behind overlay
TerminalView terminal = new TerminalView(ConsoleActivity.this, bridge);
terminal.setId(R.id.console_flip);
view.addView(terminal, 0);
synchronized (flip) {
// finally attach to the flipper
flip.addView(view);
return flip.getChildCount() - 1;
}
}
private int getFlipIndex(TerminalBridge bridge) {
synchronized (flip) {
final int children = flip.getChildCount();
for (int i = 0; i < children; i++) {
final View view = flip.getChildAt(i).findViewById(R.id.console_flip);
if (view == null || !(view instanceof TerminalView)) {
// How did that happen?
continue;
}
final TerminalView tv = (TerminalView) view;
if (tv.bridge == bridge) {
return i;
}
}
}
return -1;
}
/**
* Displays the child in the ViewFlipper at the requestedIndex and updates the prompts.
*
* @param requestedIndex the index of the terminal view to display
*/
private void setDisplayedTerminal(int requestedIndex) {
synchronized (flip) {
try {
// show the requested bridge if found, also fade out overlay
flip.setDisplayedChild(requestedIndex);
flip.getCurrentView().findViewById(R.id.terminal_overlay)
.startAnimation(fade_out_delayed);
} catch (NullPointerException npe) {
Log.d(TAG, "View went away when we were about to display it", npe);
}
updatePromptVisible();
updateEmptyVisible();
}
}
}
| 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 java.io.IOException;
import android.app.Activity;
import android.content.Intent;
import android.content.res.AssetManager;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
/**
* @author Kenny Root
*
*/
public class HelpActivity extends Activity {
public final static String TAG = "ConnectBot.HelpActivity";
public final static String HELPDIR = "help";
public final static String SUFFIX = ".html";
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.act_help);
this.setTitle(String.format("%s: %s",
getResources().getText(R.string.app_name),
getResources().getText(R.string.title_help)));
AssetManager am = this.getAssets();
LinearLayout content = (LinearLayout)this.findViewById(R.id.topics);
try {
for (String name : am.list(HELPDIR)) {
if (name.endsWith(SUFFIX)) {
Button button = new Button(this);
final String topic = name.substring(0, name.length() - SUFFIX.length());
button.setText(topic);
button.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
Intent intent = new Intent(HelpActivity.this, HelpTopicActivity.class);
intent.putExtra(Intent.EXTRA_TITLE, topic);
HelpActivity.this.startActivity(intent);
}
});
content.addView(button);
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
Log.e(TAG, "couldn't get list of help assets", 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 org.connectbot;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.connectbot.bean.SelectionArea;
import org.connectbot.service.FontSizeChangedListener;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalKeyListener;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ResolveInfo;
import android.database.Cursor;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PixelXorXfermode;
import android.graphics.RectF;
import android.net.Uri;
import android.os.AsyncTask;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
import android.view.inputmethod.BaseInputConnection;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.widget.Toast;
import de.mud.terminal.VDUBuffer;
/**
* User interface {@link View} for showing a TerminalBridge in an
* {@link Activity}. Handles drawing bitmap updates and passing keystrokes down
* to terminal.
*
* @author jsharkey
*/
public class TerminalView extends View implements FontSizeChangedListener {
private final Context context;
public final TerminalBridge bridge;
private final Paint paint;
private final Paint cursorPaint;
private final Paint cursorStrokePaint;
// Cursor paints to distinguish modes
private Path ctrlCursor, altCursor, shiftCursor;
private RectF tempSrc, tempDst;
private Matrix scaleMatrix;
private static final Matrix.ScaleToFit scaleType = Matrix.ScaleToFit.FILL;
private Toast notification = null;
private String lastNotification = null;
private volatile boolean notifications = true;
// Related to Accessibility Features
private boolean mAccessibilityInitialized = false;
private boolean mAccessibilityActive = true;
private Object[] mAccessibilityLock = new Object[0];
private StringBuffer mAccessibilityBuffer;
private Pattern mControlCodes = null;
private Matcher mCodeMatcher = null;
private AccessibilityEventSender mEventSender = null;
private static final String BACKSPACE_CODE = "\\x08\\x1b\\[K";
private static final String CONTROL_CODE_PATTERN = "\\x1b\\[K[^m]+[m|:]";
private static final int ACCESSIBILITY_EVENT_THRESHOLD = 1000;
private static final String SCREENREADER_INTENT_ACTION = "android.accessibilityservice.AccessibilityService";
private static final String SCREENREADER_INTENT_CATEGORY = "android.accessibilityservice.category.FEEDBACK_SPOKEN";
public TerminalView(Context context, TerminalBridge bridge) {
super(context);
this.context = context;
this.bridge = bridge;
paint = new Paint();
setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
setFocusable(true);
setFocusableInTouchMode(true);
cursorPaint = new Paint();
cursorPaint.setColor(bridge.color[bridge.defaultFg]);
cursorPaint.setXfermode(new PixelXorXfermode(bridge.color[bridge.defaultBg]));
cursorPaint.setAntiAlias(true);
cursorStrokePaint = new Paint(cursorPaint);
cursorStrokePaint.setStrokeWidth(0.1f);
cursorStrokePaint.setStyle(Paint.Style.STROKE);
/*
* Set up our cursor indicators on a 1x1 Path object which we can later
* transform to our character width and height
*/
// TODO make this into a resource somehow
shiftCursor = new Path();
shiftCursor.lineTo(0.5f, 0.33f);
shiftCursor.lineTo(1.0f, 0.0f);
altCursor = new Path();
altCursor.moveTo(0.0f, 1.0f);
altCursor.lineTo(0.5f, 0.66f);
altCursor.lineTo(1.0f, 1.0f);
ctrlCursor = new Path();
ctrlCursor.moveTo(0.0f, 0.25f);
ctrlCursor.lineTo(1.0f, 0.5f);
ctrlCursor.lineTo(0.0f, 0.75f);
// For creating the transform when the terminal resizes
tempSrc = new RectF();
tempSrc.set(0.0f, 0.0f, 1.0f, 1.0f);
tempDst = new RectF();
scaleMatrix = new Matrix();
bridge.addFontSizeChangedListener(this);
// connect our view up to the bridge
setOnKeyListener(bridge.getKeyHandler());
mAccessibilityBuffer = new StringBuffer();
// Enable accessibility features if a screen reader is active.
new AccessibilityStateTester().execute((Void) null);
}
public void destroy() {
// tell bridge to destroy its bitmap
bridge.parentDestroyed();
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
bridge.parentChanged(this);
scaleCursors();
}
public void onFontSizeChanged(float size) {
scaleCursors();
}
private void scaleCursors() {
// Create a scale matrix to scale our 1x1 representation of the cursor
tempDst.set(0.0f, 0.0f, bridge.charWidth, bridge.charHeight);
scaleMatrix.setRectToRect(tempSrc, tempDst, scaleType);
}
@Override
public void onDraw(Canvas canvas) {
if(bridge.bitmap != null) {
// draw the bitmap
bridge.onDraw();
// draw the bridge bitmap if it exists
canvas.drawBitmap(bridge.bitmap, 0, 0, paint);
// also draw cursor if visible
if (bridge.buffer.isCursorVisible()) {
int cursorColumn = bridge.buffer.getCursorColumn();
final int cursorRow = bridge.buffer.getCursorRow();
final int columns = bridge.buffer.getColumns();
if (cursorColumn == columns)
cursorColumn = columns - 1;
if (cursorColumn < 0 || cursorRow < 0)
return;
int currentAttribute = bridge.buffer.getAttributes(
cursorColumn, cursorRow);
boolean onWideCharacter = (currentAttribute & VDUBuffer.FULLWIDTH) != 0;
int x = cursorColumn * bridge.charWidth;
int y = (bridge.buffer.getCursorRow()
+ bridge.buffer.screenBase - bridge.buffer.windowBase)
* bridge.charHeight;
// Save the current clip and translation
canvas.save();
canvas.translate(x, y);
canvas.clipRect(0, 0,
bridge.charWidth * (onWideCharacter ? 2 : 1),
bridge.charHeight);
canvas.drawPaint(cursorPaint);
final int deadKey = bridge.getKeyHandler().getDeadKey();
if (deadKey != 0) {
canvas.drawText(new char[] { (char)deadKey }, 0, 1, 0, 0, cursorStrokePaint);
}
// Make sure we scale our decorations to the correct size.
canvas.concat(scaleMatrix);
int metaState = bridge.getKeyHandler().getMetaState();
if ((metaState & TerminalKeyListener.META_SHIFT_ON) != 0)
canvas.drawPath(shiftCursor, cursorStrokePaint);
else if ((metaState & TerminalKeyListener.META_SHIFT_LOCK) != 0)
canvas.drawPath(shiftCursor, cursorPaint);
if ((metaState & TerminalKeyListener.META_ALT_ON) != 0)
canvas.drawPath(altCursor, cursorStrokePaint);
else if ((metaState & TerminalKeyListener.META_ALT_LOCK) != 0)
canvas.drawPath(altCursor, cursorPaint);
if ((metaState & TerminalKeyListener.META_CTRL_ON) != 0)
canvas.drawPath(ctrlCursor, cursorStrokePaint);
else if ((metaState & TerminalKeyListener.META_CTRL_LOCK) != 0)
canvas.drawPath(ctrlCursor, cursorPaint);
// Restore previous clip region
canvas.restore();
}
// draw any highlighted area
if (bridge.isSelectingForCopy()) {
SelectionArea area = bridge.getSelectionArea();
canvas.save(Canvas.CLIP_SAVE_FLAG);
canvas.clipRect(
area.getLeft() * bridge.charWidth,
area.getTop() * bridge.charHeight,
(area.getRight() + 1) * bridge.charWidth,
(area.getBottom() + 1) * bridge.charHeight
);
canvas.drawPaint(cursorPaint);
canvas.restore();
}
}
}
public void notifyUser(String message) {
if (!notifications)
return;
if (notification != null) {
// Don't keep telling the user the same thing.
if (lastNotification != null && lastNotification.equals(message))
return;
notification.setText(message);
notification.show();
} else {
notification = Toast.makeText(context, message, Toast.LENGTH_SHORT);
notification.show();
}
lastNotification = message;
}
/**
* Ask the {@link TerminalBridge} we're connected to to resize to a specific size.
* @param width
* @param height
*/
public void forceSize(int width, int height) {
bridge.resizeComputed(width, height, getWidth(), getHeight());
}
/**
* Sets the ability for the TerminalView to display Toast notifications to the user.
* @param value whether to enable notifications or not
*/
public void setNotifications(boolean value) {
notifications = value;
}
@Override
public boolean onCheckIsTextEditor() {
return true;
}
@Override
public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
outAttrs.imeOptions |=
EditorInfo.IME_FLAG_NO_EXTRACT_UI |
EditorInfo.IME_FLAG_NO_ENTER_ACTION |
EditorInfo.IME_ACTION_NONE;
outAttrs.inputType = EditorInfo.TYPE_NULL;
return new BaseInputConnection(this, false) {
@Override
public boolean deleteSurroundingText (int leftLength, int rightLength) {
if (rightLength == 0 && leftLength == 0) {
return this.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL));
}
for (int i = 0; i < leftLength; i++) {
this.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL));
}
// TODO: forward delete
return true;
}
};
}
public void propagateConsoleText(char[] rawText, int length) {
if (mAccessibilityActive) {
synchronized (mAccessibilityLock) {
mAccessibilityBuffer.append(rawText, 0, length);
}
if (mAccessibilityInitialized) {
if (mEventSender != null) {
removeCallbacks(mEventSender);
} else {
mEventSender = new AccessibilityEventSender();
}
postDelayed(mEventSender, ACCESSIBILITY_EVENT_THRESHOLD);
}
}
}
private class AccessibilityEventSender implements Runnable {
public void run() {
synchronized (mAccessibilityLock) {
if (mCodeMatcher == null) {
mCodeMatcher = mControlCodes.matcher(mAccessibilityBuffer);
} else {
mCodeMatcher.reset(mAccessibilityBuffer);
}
// Strip all control codes out.
mAccessibilityBuffer = new StringBuffer(mCodeMatcher.replaceAll(" "));
// Apply Backspaces using backspace character sequence
int i = mAccessibilityBuffer.indexOf(BACKSPACE_CODE);
while (i != -1) {
mAccessibilityBuffer = mAccessibilityBuffer.replace(i == 0 ? 0 : i - 1, i
+ BACKSPACE_CODE.length(), "");
i = mAccessibilityBuffer.indexOf(BACKSPACE_CODE);
}
if (mAccessibilityBuffer.length() > 0) {
AccessibilityEvent event = AccessibilityEvent.obtain(
AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED);
event.setFromIndex(0);
event.setAddedCount(mAccessibilityBuffer.length());
event.getText().add(mAccessibilityBuffer);
sendAccessibilityEventUnchecked(event);
mAccessibilityBuffer.setLength(0);
}
}
}
}
private class AccessibilityStateTester extends AsyncTask<Void, Void, Boolean> {
@Override
protected Boolean doInBackground(Void... params) {
/*
* Presumably if the accessibility manager is not enabled, we don't
* need to send accessibility events.
*/
final AccessibilityManager accessibility = (AccessibilityManager) context
.getSystemService(Context.ACCESSIBILITY_SERVICE);
if (!accessibility.isEnabled()) {
return false;
}
/*
* Restrict the set of intents to only accessibility services that
* have the category FEEDBACK_SPOKEN (aka, screen readers).
*/
final Intent screenReaderIntent = new Intent(SCREENREADER_INTENT_ACTION);
screenReaderIntent.addCategory(SCREENREADER_INTENT_CATEGORY);
final ContentResolver cr = context.getContentResolver();
final List<ResolveInfo> screenReaders = context.getPackageManager().queryIntentServices(
screenReaderIntent, 0);
boolean foundScreenReader = false;
final int N = screenReaders.size();
for (int i = 0; i < N; i++) {
final ResolveInfo screenReader = screenReaders.get(i);
/*
* All screen readers are expected to implement a content
* provider that responds to:
* content://<nameofpackage>.providers.StatusProvider
*/
final Cursor cursor = cr.query(
Uri.parse("content://" + screenReader.serviceInfo.packageName
+ ".providers.StatusProvider"), null, null, null, null);
if (cursor != null && cursor.moveToFirst()) {
/*
* These content providers use a special cursor that only has
* one element, an integer that is 1 if the screen reader is
* running.
*/
final int status = cursor.getInt(0);
cursor.close();
if (status == 1) {
foundScreenReader = true;
break;
}
}
}
if (foundScreenReader) {
mControlCodes = Pattern.compile(CONTROL_CODE_PATTERN);
}
return foundScreenReader;
}
@Override
protected void onPostExecute(Boolean result) {
mAccessibilityActive = result;
mAccessibilityInitialized = true;
if (result) {
mEventSender = new AccessibilityEventSender();
postDelayed(mEventSender, ACCESSIBILITY_EVENT_THRESHOLD);
} else {
mAccessibilityBuffer = null;
}
}
}
}
| 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.util.HelpTopicView;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
/**
* @author Kenny Root
*
*/
public class HelpTopicActivity extends Activity {
public final static String TAG = "ConnectBot.HelpActivity";
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.act_help_topic);
String topic = getIntent().getStringExtra(Intent.EXTRA_TITLE);
this.setTitle(String.format("%s: %s - %s",
getResources().getText(R.string.app_name),
getResources().getText(R.string.title_help),
topic));
HelpTopicView helpTopic = (HelpTopicView) findViewById(R.id.topic_text);
helpTopic.setTopic(topic);
}
}
| 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 java.nio.charset.Charset;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import org.connectbot.bean.HostBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import org.connectbot.util.HostDatabase;
import org.connectbot.util.PubkeyDatabase;
import android.content.ComponentName;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.os.IBinder;
import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.util.Log;
public class HostEditorActivity extends PreferenceActivity implements OnSharedPreferenceChangeListener {
public class CursorPreferenceHack implements SharedPreferences {
protected final String table;
protected final long id;
protected Map<String, String> values = new HashMap<String, String>();
// protected Map<String, String> pubkeys = new HashMap<String, String>();
public CursorPreferenceHack(String table, long id) {
this.table = table;
this.id = id;
cacheValues();
}
protected final void cacheValues() {
// fill a cursor and cache the values locally
// this makes sure we dont have any floating cursor to dispose later
SQLiteDatabase db = hostdb.getReadableDatabase();
Cursor cursor = db.query(table, null, "_id = ?",
new String[] { String.valueOf(id) }, null, null, null);
if (cursor.moveToFirst()) {
for(int i = 0; i < cursor.getColumnCount(); i++) {
String key = cursor.getColumnName(i);
if(key.equals(HostDatabase.FIELD_HOST_HOSTKEY)) continue;
String value = cursor.getString(i);
values.put(key, value);
}
}
cursor.close();
db.close();
// db = pubkeydb.getReadableDatabase();
// cursor = db.query(PubkeyDatabase.TABLE_PUBKEYS,
// new String[] { "_id", PubkeyDatabase.FIELD_PUBKEY_NICKNAME },
// null, null, null, null, null);
//
// if (cursor.moveToFirst()) {
// do {
// String pubkeyid = String.valueOf(cursor.getLong(0));
// String value = cursor.getString(1);
// pubkeys.put(pubkeyid, value);
// } while (cursor.moveToNext());
// }
//
// cursor.close();
// db.close();
}
public boolean contains(String key) {
return values.containsKey(key);
}
public class Editor implements SharedPreferences.Editor {
private ContentValues update = new ContentValues();
public SharedPreferences.Editor clear() {
Log.d(this.getClass().toString(), "clear()");
update = new ContentValues();
return this;
}
public boolean commit() {
//Log.d(this.getClass().toString(), "commit() changes back to database");
SQLiteDatabase db = hostdb.getWritableDatabase();
db.update(table, update, "_id = ?", new String[] { String.valueOf(id) });
db.close();
// make sure we refresh the parent cached values
cacheValues();
// and update any listeners
for(OnSharedPreferenceChangeListener listener : listeners) {
listener.onSharedPreferenceChanged(CursorPreferenceHack.this, null);
}
return true;
}
// Gingerbread compatibility
public void apply() {
commit();
}
public android.content.SharedPreferences.Editor putBoolean(String key, boolean value) {
return this.putString(key, Boolean.toString(value));
}
public android.content.SharedPreferences.Editor putFloat(String key, float value) {
return this.putString(key, Float.toString(value));
}
public android.content.SharedPreferences.Editor putInt(String key, int value) {
return this.putString(key, Integer.toString(value));
}
public android.content.SharedPreferences.Editor putLong(String key, long value) {
return this.putString(key, Long.toString(value));
}
public android.content.SharedPreferences.Editor putString(String key, String value) {
//Log.d(this.getClass().toString(), String.format("Editor.putString(key=%s, value=%s)", key, value));
update.put(key, value);
return this;
}
public android.content.SharedPreferences.Editor remove(String key) {
//Log.d(this.getClass().toString(), String.format("Editor.remove(key=%s)", key));
update.remove(key);
return this;
}
public android.content.SharedPreferences.Editor putStringSet(String key, Set<String> value) {
throw new UnsupportedOperationException("HostEditor Prefs do not support Set<String>");
}
}
public Editor edit() {
//Log.d(this.getClass().toString(), "edit()");
return new Editor();
}
public Map<String, ?> getAll() {
return values;
}
public boolean getBoolean(String key, boolean defValue) {
return Boolean.valueOf(this.getString(key, Boolean.toString(defValue)));
}
public float getFloat(String key, float defValue) {
return Float.valueOf(this.getString(key, Float.toString(defValue)));
}
public int getInt(String key, int defValue) {
return Integer.valueOf(this.getString(key, Integer.toString(defValue)));
}
public long getLong(String key, long defValue) {
return Long.valueOf(this.getString(key, Long.toString(defValue)));
}
public String getString(String key, String defValue) {
//Log.d(this.getClass().toString(), String.format("getString(key=%s, defValue=%s)", key, defValue));
if(!values.containsKey(key)) return defValue;
return values.get(key);
}
public Set<String> getStringSet(String key, Set<String> defValue) {
throw new ClassCastException("HostEditor Prefs do not support Set<String>");
}
protected List<OnSharedPreferenceChangeListener> listeners = new LinkedList<OnSharedPreferenceChangeListener>();
public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
listeners.add(listener);
}
public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
listeners.remove(listener);
}
}
@Override
public SharedPreferences getSharedPreferences(String name, int mode) {
//Log.d(this.getClass().toString(), String.format("getSharedPreferences(name=%s)", name));
return this.pref;
}
protected static final String TAG = "ConnectBot.HostEditorActivity";
protected HostDatabase hostdb = null;
private PubkeyDatabase pubkeydb = null;
private CursorPreferenceHack pref;
private ServiceConnection connection;
private HostBean host;
protected TerminalBridge hostBridge;
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
long hostId = this.getIntent().getLongExtra(Intent.EXTRA_TITLE, -1);
// TODO: we could pass through a specific ContentProvider uri here
//this.getPreferenceManager().setSharedPreferencesName(uri);
this.hostdb = new HostDatabase(this);
this.pubkeydb = new PubkeyDatabase(this);
host = hostdb.findHostById(hostId);
connection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
TerminalManager bound = ((TerminalManager.TerminalBinder) service).getService();
hostBridge = bound.getConnectedBridge(host);
}
public void onServiceDisconnected(ComponentName name) {
hostBridge = null;
}
};
this.pref = new CursorPreferenceHack(HostDatabase.TABLE_HOSTS, hostId);
this.pref.registerOnSharedPreferenceChangeListener(this);
this.addPreferencesFromResource(R.xml.host_prefs);
// add all existing pubkeys to our listpreference for user to choose from
// TODO: may be an issue here when this activity is recycled after adding a new pubkey
// TODO: should consider moving into onStart, but we dont have a good way of resetting the listpref after filling once
ListPreference pubkeyPref = (ListPreference)this.findPreference(HostDatabase.FIELD_HOST_PUBKEYID);
List<CharSequence> pubkeyNicks = new LinkedList<CharSequence>(Arrays.asList(pubkeyPref.getEntries()));
pubkeyNicks.addAll(pubkeydb.allValues(PubkeyDatabase.FIELD_PUBKEY_NICKNAME));
pubkeyPref.setEntries(pubkeyNicks.toArray(new CharSequence[pubkeyNicks.size()]));
List<CharSequence> pubkeyIds = new LinkedList<CharSequence>(Arrays.asList(pubkeyPref.getEntryValues()));
pubkeyIds.addAll(pubkeydb.allValues("_id"));
pubkeyPref.setEntryValues(pubkeyIds.toArray(new CharSequence[pubkeyIds.size()]));
// Populate the character set encoding list with all available
final ListPreference charsetPref = (ListPreference) findPreference(HostDatabase.FIELD_HOST_ENCODING);
if (CharsetHolder.isInitialized()) {
initCharsetPref(charsetPref);
} else {
String[] currentCharsetPref = new String[1];
currentCharsetPref[0] = charsetPref.getValue();
charsetPref.setEntryValues(currentCharsetPref);
charsetPref.setEntries(currentCharsetPref);
new Thread(new Runnable() {
public void run() {
initCharsetPref(charsetPref);
}
}).start();
}
this.updateSummaries();
}
@Override
public void onStart() {
super.onStart();
bindService(new Intent(this, TerminalManager.class), connection, Context.BIND_AUTO_CREATE);
if(this.hostdb == null)
this.hostdb = new HostDatabase(this);
if(this.pubkeydb == null)
this.pubkeydb = new PubkeyDatabase(this);
}
@Override
public void onStop() {
super.onStop();
unbindService(connection);
if(this.hostdb != null) {
this.hostdb.close();
this.hostdb = null;
}
if(this.pubkeydb != null) {
this.pubkeydb.close();
this.pubkeydb = null;
}
}
private void updateSummaries() {
// for all text preferences, set hint as current database value
for (String key : this.pref.values.keySet()) {
if(key.equals(HostDatabase.FIELD_HOST_POSTLOGIN)) continue;
Preference pref = this.findPreference(key);
if(pref == null) continue;
if(pref instanceof CheckBoxPreference) continue;
CharSequence value = this.pref.getString(key, "");
if (key.equals(HostDatabase.FIELD_HOST_PUBKEYID)) {
try {
int pubkeyId = Integer.parseInt((String) value);
if (pubkeyId >= 0)
pref.setSummary(pubkeydb.getNickname(pubkeyId));
else if(pubkeyId == HostDatabase.PUBKEYID_ANY)
pref.setSummary(R.string.list_pubkeyids_any);
else if(pubkeyId == HostDatabase.PUBKEYID_NEVER)
pref.setSummary(R.string.list_pubkeyids_none);
continue;
} catch (NumberFormatException nfe) {
// Fall through.
}
} else if (pref instanceof ListPreference) {
ListPreference listPref = (ListPreference) pref;
int entryIndex = listPref.findIndexOfValue((String) value);
if (entryIndex >= 0)
value = listPref.getEntries()[entryIndex];
}
pref.setSummary(value);
}
}
private void initCharsetPref(final ListPreference charsetPref) {
charsetPref.setEntryValues(CharsetHolder.getCharsetIds());
charsetPref.setEntries(CharsetHolder.getCharsetNames());
}
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
// update values on changed preference
this.updateSummaries();
// Our CursorPreferenceHack always send null keys, so try to set charset anyway
if (hostBridge != null)
hostBridge.setCharset(sharedPreferences
.getString(HostDatabase.FIELD_HOST_ENCODING, HostDatabase.ENCODING_DEFAULT));
}
public static class CharsetHolder {
private static boolean initialized = false;
private static CharSequence[] charsetIds;
private static CharSequence[] charsetNames;
public static CharSequence[] getCharsetNames() {
if (charsetNames == null)
initialize();
return charsetNames;
}
public static CharSequence[] getCharsetIds() {
if (charsetIds == null)
initialize();
return charsetIds;
}
private synchronized static void initialize() {
if (initialized)
return;
List<CharSequence> charsetIdsList = new LinkedList<CharSequence>();
List<CharSequence> charsetNamesList = new LinkedList<CharSequence>();
for (Entry<String, Charset> entry : Charset.availableCharsets().entrySet()) {
Charset c = entry.getValue();
if (c.canEncode() && c.isRegistered()) {
String key = entry.getKey();
if (key.startsWith("cp")) {
// Custom CP437 charset changes
charsetIdsList.add("CP437");
charsetNamesList.add("CP437");
}
charsetIdsList.add(entry.getKey());
charsetNamesList.add(c.displayName());
}
}
charsetIds = charsetIdsList.toArray(new CharSequence[charsetIdsList.size()]);
charsetNames = charsetNamesList.toArray(new CharSequence[charsetNamesList.size()]);
initialized = true;
}
public static boolean isInitialized() {
return initialized;
}
}
}
| 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.transport;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.connectbot.R;
import org.connectbot.bean.HostBean;
import org.connectbot.bean.PortForwardBean;
import org.connectbot.bean.PubkeyBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import org.connectbot.service.TerminalManager.KeyHolder;
import org.connectbot.util.HostDatabase;
import org.connectbot.util.PubkeyDatabase;
import org.connectbot.util.PubkeyUtils;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
import com.trilead.ssh2.AuthAgentCallback;
import com.trilead.ssh2.ChannelCondition;
import com.trilead.ssh2.Connection;
import com.trilead.ssh2.ConnectionInfo;
import com.trilead.ssh2.ConnectionMonitor;
import com.trilead.ssh2.DynamicPortForwarder;
import com.trilead.ssh2.InteractiveCallback;
import com.trilead.ssh2.KnownHosts;
import com.trilead.ssh2.LocalPortForwarder;
import com.trilead.ssh2.ServerHostKeyVerifier;
import com.trilead.ssh2.Session;
import com.trilead.ssh2.crypto.PEMDecoder;
import com.trilead.ssh2.signature.DSAPrivateKey;
import com.trilead.ssh2.signature.DSAPublicKey;
import com.trilead.ssh2.signature.DSASHA1Verify;
import com.trilead.ssh2.signature.RSAPrivateKey;
import com.trilead.ssh2.signature.RSAPublicKey;
import com.trilead.ssh2.signature.RSASHA1Verify;
/**
* @author Kenny Root
*
*/
public class SSH extends AbsTransport implements ConnectionMonitor, InteractiveCallback, AuthAgentCallback {
public SSH() {
super();
}
/**
* @param bridge
* @param db
*/
public SSH(HostBean host, TerminalBridge bridge, TerminalManager manager) {
super(host, bridge, manager);
}
private static final String PROTOCOL = "ssh";
private static final String TAG = "ConnectBot.SSH";
private static final int DEFAULT_PORT = 22;
private static final String AUTH_PUBLICKEY = "publickey",
AUTH_PASSWORD = "password",
AUTH_KEYBOARDINTERACTIVE = "keyboard-interactive";
private final static int AUTH_TRIES = 20;
static final Pattern hostmask;
static {
hostmask = Pattern.compile("^(.+)@([0-9a-z.-]+)(:(\\d+))?$", Pattern.CASE_INSENSITIVE);
}
private boolean compression = false;
private volatile boolean authenticated = false;
private volatile boolean connected = false;
private volatile boolean sessionOpen = false;
private boolean pubkeysExhausted = false;
private boolean interactiveCanContinue = true;
private Connection connection;
private Session session;
private ConnectionInfo connectionInfo;
private OutputStream stdin;
private InputStream stdout;
private InputStream stderr;
private static final int conditions = ChannelCondition.STDOUT_DATA
| ChannelCondition.STDERR_DATA
| ChannelCondition.CLOSED
| ChannelCondition.EOF;
private List<PortForwardBean> portForwards = new LinkedList<PortForwardBean>();
private int columns;
private int rows;
private int width;
private int height;
private String useAuthAgent = HostDatabase.AUTHAGENT_NO;
private String agentLockPassphrase;
public class HostKeyVerifier implements ServerHostKeyVerifier {
public boolean verifyServerHostKey(String hostname, int port,
String serverHostKeyAlgorithm, byte[] serverHostKey) throws IOException {
// read in all known hosts from hostdb
KnownHosts hosts = manager.hostdb.getKnownHosts();
Boolean result;
String matchName = String.format("%s:%d", hostname, port);
String fingerprint = KnownHosts.createHexFingerprint(serverHostKeyAlgorithm, serverHostKey);
String algorithmName;
if ("ssh-rsa".equals(serverHostKeyAlgorithm))
algorithmName = "RSA";
else if ("ssh-dss".equals(serverHostKeyAlgorithm))
algorithmName = "DSA";
else
algorithmName = serverHostKeyAlgorithm;
switch(hosts.verifyHostkey(matchName, serverHostKeyAlgorithm, serverHostKey)) {
case KnownHosts.HOSTKEY_IS_OK:
bridge.outputLine(manager.res.getString(R.string.terminal_sucess, algorithmName, fingerprint));
return true;
case KnownHosts.HOSTKEY_IS_NEW:
// prompt user
bridge.outputLine(manager.res.getString(R.string.host_authenticity_warning, hostname));
bridge.outputLine(manager.res.getString(R.string.host_fingerprint, algorithmName, fingerprint));
result = bridge.promptHelper.requestBooleanPrompt(null, manager.res.getString(R.string.prompt_continue_connecting));
if(result == null) return false;
if(result.booleanValue()) {
// save this key in known database
manager.hostdb.saveKnownHost(hostname, port, serverHostKeyAlgorithm, serverHostKey);
}
return result.booleanValue();
case KnownHosts.HOSTKEY_HAS_CHANGED:
String header = String.format("@ %s @",
manager.res.getString(R.string.host_verification_failure_warning_header));
char[] atsigns = new char[header.length()];
Arrays.fill(atsigns, '@');
String border = new String(atsigns);
bridge.outputLine(border);
bridge.outputLine(manager.res.getString(R.string.host_verification_failure_warning));
bridge.outputLine(border);
bridge.outputLine(String.format(manager.res.getString(R.string.host_fingerprint),
algorithmName, fingerprint));
// Users have no way to delete keys, so we'll prompt them for now.
result = bridge.promptHelper.requestBooleanPrompt(null, manager.res.getString(R.string.prompt_continue_connecting));
if(result == null) return false;
if(result.booleanValue()) {
// save this key in known database
manager.hostdb.saveKnownHost(hostname, port, serverHostKeyAlgorithm, serverHostKey);
}
return result.booleanValue();
default:
return false;
}
}
}
private void authenticate() {
try {
if (connection.authenticateWithNone(host.getUsername())) {
finishConnection();
return;
}
} catch(Exception e) {
Log.d(TAG, "Host does not support 'none' authentication.");
}
bridge.outputLine(manager.res.getString(R.string.terminal_auth));
try {
long pubkeyId = host.getPubkeyId();
if (!pubkeysExhausted &&
pubkeyId != HostDatabase.PUBKEYID_NEVER &&
connection.isAuthMethodAvailable(host.getUsername(), AUTH_PUBLICKEY)) {
// if explicit pubkey defined for this host, then prompt for password as needed
// otherwise just try all in-memory keys held in terminalmanager
if (pubkeyId == HostDatabase.PUBKEYID_ANY) {
// try each of the in-memory keys
bridge.outputLine(manager.res
.getString(R.string.terminal_auth_pubkey_any));
for (Entry<String, KeyHolder> entry : manager.loadedKeypairs.entrySet()) {
if (entry.getValue().bean.isConfirmUse()
&& !promptForPubkeyUse(entry.getKey()))
continue;
if (this.tryPublicKey(host.getUsername(), entry.getKey(),
entry.getValue().trileadKey)) {
finishConnection();
break;
}
}
} else {
bridge.outputLine(manager.res.getString(R.string.terminal_auth_pubkey_specific));
// use a specific key for this host, as requested
PubkeyBean pubkey = manager.pubkeydb.findPubkeyById(pubkeyId);
if (pubkey == null)
bridge.outputLine(manager.res.getString(R.string.terminal_auth_pubkey_invalid));
else
if (tryPublicKey(pubkey))
finishConnection();
}
pubkeysExhausted = true;
} else if (interactiveCanContinue &&
connection.isAuthMethodAvailable(host.getUsername(), AUTH_KEYBOARDINTERACTIVE)) {
// this auth method will talk with us using InteractiveCallback interface
// it blocks until authentication finishes
bridge.outputLine(manager.res.getString(R.string.terminal_auth_ki));
interactiveCanContinue = false;
if(connection.authenticateWithKeyboardInteractive(host.getUsername(), this)) {
finishConnection();
} else {
bridge.outputLine(manager.res.getString(R.string.terminal_auth_ki_fail));
}
} else if (connection.isAuthMethodAvailable(host.getUsername(), AUTH_PASSWORD)) {
bridge.outputLine(manager.res.getString(R.string.terminal_auth_pass));
String password = bridge.getPromptHelper().requestStringPrompt(null,
manager.res.getString(R.string.prompt_password));
if (password != null
&& connection.authenticateWithPassword(host.getUsername(), password)) {
finishConnection();
} else {
bridge.outputLine(manager.res.getString(R.string.terminal_auth_pass_fail));
}
} else {
bridge.outputLine(manager.res.getString(R.string.terminal_auth_fail));
}
} catch (IllegalStateException e) {
Log.e(TAG, "Connection went away while we were trying to authenticate", e);
return;
} catch(Exception e) {
Log.e(TAG, "Problem during handleAuthentication()", e);
}
}
/**
* Attempt connection with database row pointed to by cursor.
* @param cursor
* @return true for successful authentication
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
* @throws IOException
*/
private boolean tryPublicKey(PubkeyBean pubkey) throws NoSuchAlgorithmException, InvalidKeySpecException, IOException {
Object trileadKey = null;
if(manager.isKeyLoaded(pubkey.getNickname())) {
// load this key from memory if its already there
Log.d(TAG, String.format("Found unlocked key '%s' already in-memory", pubkey.getNickname()));
if (pubkey.isConfirmUse()) {
if (!promptForPubkeyUse(pubkey.getNickname()))
return false;
}
trileadKey = manager.getKey(pubkey.getNickname());
} else {
// otherwise load key from database and prompt for password as needed
String password = null;
if (pubkey.isEncrypted()) {
password = bridge.getPromptHelper().requestStringPrompt(null,
manager.res.getString(R.string.prompt_pubkey_password, pubkey.getNickname()));
// Something must have interrupted the prompt.
if (password == null)
return false;
}
if(PubkeyDatabase.KEY_TYPE_IMPORTED.equals(pubkey.getType())) {
// load specific key using pem format
trileadKey = PEMDecoder.decode(new String(pubkey.getPrivateKey()).toCharArray(), password);
} else {
// load using internal generated format
PrivateKey privKey;
try {
privKey = PubkeyUtils.decodePrivate(pubkey.getPrivateKey(),
pubkey.getType(), password);
} catch (Exception e) {
String message = String.format("Bad password for key '%s'. Authentication failed.", pubkey.getNickname());
Log.e(TAG, message, e);
bridge.outputLine(message);
return false;
}
PublicKey pubKey = pubkey.getPublicKey();
// convert key to trilead format
trileadKey = PubkeyUtils.convertToTrilead(privKey, pubKey);
Log.d(TAG, "Unlocked key " + PubkeyUtils.formatKey(pubKey));
}
Log.d(TAG, String.format("Unlocked key '%s'", pubkey.getNickname()));
// save this key in memory
manager.addKey(pubkey, trileadKey);
}
return tryPublicKey(host.getUsername(), pubkey.getNickname(), trileadKey);
}
private boolean tryPublicKey(String username, String keyNickname, Object trileadKey) throws IOException {
//bridge.outputLine(String.format("Attempting 'publickey' with key '%s' [%s]...", keyNickname, trileadKey.toString()));
boolean success = connection.authenticateWithPublicKey(username, trileadKey);
if(!success)
bridge.outputLine(manager.res.getString(R.string.terminal_auth_pubkey_fail, keyNickname));
return success;
}
/**
* Internal method to request actual PTY terminal once we've finished
* authentication. If called before authenticated, it will just fail.
*/
private void finishConnection() {
authenticated = true;
for (PortForwardBean portForward : portForwards) {
try {
enablePortForward(portForward);
bridge.outputLine(manager.res.getString(R.string.terminal_enable_portfoward, portForward.getDescription()));
} catch (Exception e) {
Log.e(TAG, "Error setting up port forward during connect", e);
}
}
if (!host.getWantSession()) {
bridge.outputLine(manager.res.getString(R.string.terminal_no_session));
bridge.onConnected();
return;
}
try {
session = connection.openSession();
if (!useAuthAgent.equals(HostDatabase.AUTHAGENT_NO))
session.requestAuthAgentForwarding(this);
session.requestPTY(getEmulation(), columns, rows, width, height, null);
session.startShell();
stdin = session.getStdin();
stdout = session.getStdout();
stderr = session.getStderr();
sessionOpen = true;
bridge.onConnected();
} catch (IOException e1) {
Log.e(TAG, "Problem while trying to create PTY in finishConnection()", e1);
}
}
@Override
public void connect() {
connection = new Connection(host.getHostname(), host.getPort());
connection.addConnectionMonitor(this);
try {
connection.setCompression(compression);
} catch (IOException e) {
Log.e(TAG, "Could not enable compression!", e);
}
try {
/* Uncomment when debugging SSH protocol:
DebugLogger logger = new DebugLogger() {
public void log(int level, String className, String message) {
Log.d("SSH", message);
}
};
Logger.enabled = true;
Logger.logger = logger;
*/
connectionInfo = connection.connect(new HostKeyVerifier());
connected = true;
if (connectionInfo.clientToServerCryptoAlgorithm
.equals(connectionInfo.serverToClientCryptoAlgorithm)
&& connectionInfo.clientToServerMACAlgorithm
.equals(connectionInfo.serverToClientMACAlgorithm)) {
bridge.outputLine(manager.res.getString(R.string.terminal_using_algorithm,
connectionInfo.clientToServerCryptoAlgorithm,
connectionInfo.clientToServerMACAlgorithm));
} else {
bridge.outputLine(manager.res.getString(
R.string.terminal_using_c2s_algorithm,
connectionInfo.clientToServerCryptoAlgorithm,
connectionInfo.clientToServerMACAlgorithm));
bridge.outputLine(manager.res.getString(
R.string.terminal_using_s2c_algorithm,
connectionInfo.serverToClientCryptoAlgorithm,
connectionInfo.serverToClientMACAlgorithm));
}
} catch (IOException e) {
Log.e(TAG, "Problem in SSH connection thread during authentication", e);
// Display the reason in the text.
bridge.outputLine(e.getCause().getMessage());
onDisconnect();
return;
}
try {
// enter a loop to keep trying until authentication
int tries = 0;
while (connected && !connection.isAuthenticationComplete() && tries++ < AUTH_TRIES) {
authenticate();
// sleep to make sure we dont kill system
Thread.sleep(1000);
}
} catch(Exception e) {
Log.e(TAG, "Problem in SSH connection thread during authentication", e);
}
}
@Override
public void close() {
connected = false;
if (session != null) {
session.close();
session = null;
}
if (connection != null) {
connection.close();
connection = null;
}
}
private void onDisconnect() {
close();
bridge.dispatchDisconnect(false);
}
@Override
public void flush() throws IOException {
if (stdin != null)
stdin.flush();
}
@Override
public int read(byte[] buffer, int start, int len) throws IOException {
int bytesRead = 0;
if (session == null)
return 0;
int newConditions = session.waitForCondition(conditions, 0);
if ((newConditions & ChannelCondition.STDOUT_DATA) != 0) {
bytesRead = stdout.read(buffer, start, len);
}
if ((newConditions & ChannelCondition.STDERR_DATA) != 0) {
byte discard[] = new byte[256];
while (stderr.available() > 0) {
stderr.read(discard);
}
}
if ((newConditions & ChannelCondition.EOF) != 0) {
onDisconnect();
throw new IOException("Remote end closed connection");
}
return bytesRead;
}
@Override
public void write(byte[] buffer) throws IOException {
if (stdin != null)
stdin.write(buffer);
}
@Override
public void write(int c) throws IOException {
if (stdin != null)
stdin.write(c);
}
@Override
public Map<String, String> getOptions() {
Map<String, String> options = new HashMap<String, String>();
options.put("compression", Boolean.toString(compression));
return options;
}
@Override
public void setOptions(Map<String, String> options) {
if (options.containsKey("compression"))
compression = Boolean.parseBoolean(options.get("compression"));
}
public static String getProtocolName() {
return PROTOCOL;
}
@Override
public boolean isSessionOpen() {
return sessionOpen;
}
@Override
public boolean isConnected() {
return connected;
}
public void connectionLost(Throwable reason) {
onDisconnect();
}
@Override
public boolean canForwardPorts() {
return true;
}
@Override
public List<PortForwardBean> getPortForwards() {
return portForwards;
}
@Override
public boolean addPortForward(PortForwardBean portForward) {
return portForwards.add(portForward);
}
@Override
public boolean removePortForward(PortForwardBean portForward) {
// Make sure we don't have a phantom forwarder.
disablePortForward(portForward);
return portForwards.remove(portForward);
}
@Override
public boolean enablePortForward(PortForwardBean portForward) {
if (!portForwards.contains(portForward)) {
Log.e(TAG, "Attempt to enable port forward not in list");
return false;
}
if (!authenticated)
return false;
if (HostDatabase.PORTFORWARD_LOCAL.equals(portForward.getType())) {
LocalPortForwarder lpf = null;
try {
lpf = connection.createLocalPortForwarder(
new InetSocketAddress(InetAddress.getLocalHost(), portForward.getSourcePort()),
portForward.getDestAddr(), portForward.getDestPort());
} catch (Exception e) {
Log.e(TAG, "Could not create local port forward", e);
return false;
}
if (lpf == null) {
Log.e(TAG, "returned LocalPortForwarder object is null");
return false;
}
portForward.setIdentifier(lpf);
portForward.setEnabled(true);
return true;
} else if (HostDatabase.PORTFORWARD_REMOTE.equals(portForward.getType())) {
try {
connection.requestRemotePortForwarding("", portForward.getSourcePort(), portForward.getDestAddr(), portForward.getDestPort());
} catch (Exception e) {
Log.e(TAG, "Could not create remote port forward", e);
return false;
}
portForward.setEnabled(true);
return true;
} else if (HostDatabase.PORTFORWARD_DYNAMIC5.equals(portForward.getType())) {
DynamicPortForwarder dpf = null;
try {
dpf = connection.createDynamicPortForwarder(
new InetSocketAddress(InetAddress.getLocalHost(), portForward.getSourcePort()));
} catch (Exception e) {
Log.e(TAG, "Could not create dynamic port forward", e);
return false;
}
portForward.setIdentifier(dpf);
portForward.setEnabled(true);
return true;
} else {
// Unsupported type
Log.e(TAG, String.format("attempt to forward unknown type %s", portForward.getType()));
return false;
}
}
@Override
public boolean disablePortForward(PortForwardBean portForward) {
if (!portForwards.contains(portForward)) {
Log.e(TAG, "Attempt to disable port forward not in list");
return false;
}
if (!authenticated)
return false;
if (HostDatabase.PORTFORWARD_LOCAL.equals(portForward.getType())) {
LocalPortForwarder lpf = null;
lpf = (LocalPortForwarder)portForward.getIdentifier();
if (!portForward.isEnabled() || lpf == null) {
Log.d(TAG, String.format("Could not disable %s; it appears to be not enabled or have no handler", portForward.getNickname()));
return false;
}
portForward.setEnabled(false);
try {
lpf.close();
} catch (IOException e) {
Log.e(TAG, "Could not stop local port forwarder, setting enabled to false", e);
return false;
}
return true;
} else if (HostDatabase.PORTFORWARD_REMOTE.equals(portForward.getType())) {
portForward.setEnabled(false);
try {
connection.cancelRemotePortForwarding(portForward.getSourcePort());
} catch (IOException e) {
Log.e(TAG, "Could not stop remote port forwarding, setting enabled to false", e);
return false;
}
return true;
} else if (HostDatabase.PORTFORWARD_DYNAMIC5.equals(portForward.getType())) {
DynamicPortForwarder dpf = null;
dpf = (DynamicPortForwarder)portForward.getIdentifier();
if (!portForward.isEnabled() || dpf == null) {
Log.d(TAG, String.format("Could not disable %s; it appears to be not enabled or have no handler", portForward.getNickname()));
return false;
}
portForward.setEnabled(false);
try {
dpf.close();
} catch (IOException e) {
Log.e(TAG, "Could not stop dynamic port forwarder, setting enabled to false", e);
return false;
}
return true;
} else {
// Unsupported type
Log.e(TAG, String.format("attempt to forward unknown type %s", portForward.getType()));
return false;
}
}
@Override
public void setDimensions(int columns, int rows, int width, int height) {
this.columns = columns;
this.rows = rows;
if (sessionOpen) {
try {
session.resizePTY(columns, rows, width, height);
} catch (IOException e) {
Log.e(TAG, "Couldn't send resize PTY packet", e);
}
}
}
@Override
public int getDefaultPort() {
return DEFAULT_PORT;
}
@Override
public String getDefaultNickname(String username, String hostname, int port) {
if (port == DEFAULT_PORT) {
return String.format("%s@%s", username, hostname);
} else {
return String.format("%s@%s:%d", username, hostname, port);
}
}
public static Uri getUri(String input) {
Matcher matcher = hostmask.matcher(input);
if (!matcher.matches())
return null;
StringBuilder sb = new StringBuilder();
sb.append(PROTOCOL)
.append("://")
.append(Uri.encode(matcher.group(1)))
.append('@')
.append(matcher.group(2));
String portString = matcher.group(4);
int port = DEFAULT_PORT;
if (portString != null) {
try {
port = Integer.parseInt(portString);
if (port < 1 || port > 65535) {
port = DEFAULT_PORT;
}
} catch (NumberFormatException nfe) {
// Keep the default port
}
}
if (port != DEFAULT_PORT) {
sb.append(':')
.append(port);
}
sb.append("/#")
.append(Uri.encode(input));
Uri uri = Uri.parse(sb.toString());
return uri;
}
/**
* Handle challenges from keyboard-interactive authentication mode.
*/
public String[] replyToChallenge(String name, String instruction, int numPrompts, String[] prompt, boolean[] echo) {
interactiveCanContinue = true;
String[] responses = new String[numPrompts];
for(int i = 0; i < numPrompts; i++) {
// request response from user for each prompt
responses[i] = bridge.promptHelper.requestStringPrompt(instruction, prompt[i]);
}
return responses;
}
@Override
public HostBean createHost(Uri uri) {
HostBean host = new HostBean();
host.setProtocol(PROTOCOL);
host.setHostname(uri.getHost());
int port = uri.getPort();
if (port < 0)
port = DEFAULT_PORT;
host.setPort(port);
host.setUsername(uri.getUserInfo());
String nickname = uri.getFragment();
if (nickname == null || nickname.length() == 0) {
host.setNickname(getDefaultNickname(host.getUsername(),
host.getHostname(), host.getPort()));
} else {
host.setNickname(uri.getFragment());
}
return host;
}
@Override
public void getSelectionArgs(Uri uri, Map<String, String> selection) {
selection.put(HostDatabase.FIELD_HOST_PROTOCOL, PROTOCOL);
selection.put(HostDatabase.FIELD_HOST_NICKNAME, uri.getFragment());
selection.put(HostDatabase.FIELD_HOST_HOSTNAME, uri.getHost());
int port = uri.getPort();
if (port < 0)
port = DEFAULT_PORT;
selection.put(HostDatabase.FIELD_HOST_PORT, Integer.toString(port));
selection.put(HostDatabase.FIELD_HOST_USERNAME, uri.getUserInfo());
}
@Override
public void setCompression(boolean compression) {
this.compression = compression;
}
public static String getFormatHint(Context context) {
return String.format("%s@%s:%s",
context.getString(R.string.format_username),
context.getString(R.string.format_hostname),
context.getString(R.string.format_port));
}
@Override
public void setUseAuthAgent(String useAuthAgent) {
this.useAuthAgent = useAuthAgent;
}
public Map<String,byte[]> retrieveIdentities() {
Map<String,byte[]> pubKeys = new HashMap<String,byte[]>(manager.loadedKeypairs.size());
for (Entry<String,KeyHolder> entry : manager.loadedKeypairs.entrySet()) {
Object trileadKey = entry.getValue().trileadKey;
try {
if (trileadKey instanceof RSAPrivateKey) {
RSAPublicKey pubkey = ((RSAPrivateKey) trileadKey).getPublicKey();
pubKeys.put(entry.getKey(), RSASHA1Verify.encodeSSHRSAPublicKey(pubkey));
} else if (trileadKey instanceof DSAPrivateKey) {
DSAPublicKey pubkey = ((DSAPrivateKey) trileadKey).getPublicKey();
pubKeys.put(entry.getKey(), DSASHA1Verify.encodeSSHDSAPublicKey(pubkey));
} else
continue;
} catch (IOException e) {
continue;
}
}
return pubKeys;
}
public Object getPrivateKey(byte[] publicKey) {
String nickname = manager.getKeyNickname(publicKey);
if (nickname == null)
return null;
if (useAuthAgent.equals(HostDatabase.AUTHAGENT_NO)) {
Log.e(TAG, "");
return null;
} else if (useAuthAgent.equals(HostDatabase.AUTHAGENT_CONFIRM) ||
manager.loadedKeypairs.get(nickname).bean.isConfirmUse()) {
if (!promptForPubkeyUse(nickname))
return null;
}
return manager.getKey(nickname);
}
private boolean promptForPubkeyUse(String nickname) {
Boolean result = bridge.promptHelper.requestBooleanPrompt(null,
manager.res.getString(R.string.prompt_allow_agent_to_use_key,
nickname));
return result;
}
public boolean addIdentity(Object key, String comment, boolean confirmUse, int lifetime) {
PubkeyBean pubkey = new PubkeyBean();
// pubkey.setType(PubkeyDatabase.KEY_TYPE_IMPORTED);
pubkey.setNickname(comment);
pubkey.setConfirmUse(confirmUse);
pubkey.setLifetime(lifetime);
manager.addKey(pubkey, key);
return true;
}
public boolean removeAllIdentities() {
manager.loadedKeypairs.clear();
return true;
}
public boolean removeIdentity(byte[] publicKey) {
return manager.removeKey(publicKey);
}
public boolean isAgentLocked() {
return agentLockPassphrase != null;
}
public boolean requestAgentUnlock(String unlockPassphrase) {
if (agentLockPassphrase == null)
return false;
if (agentLockPassphrase.equals(unlockPassphrase))
agentLockPassphrase = null;
return agentLockPassphrase == null;
}
public boolean setAgentLock(String lockPassphrase) {
if (agentLockPassphrase != null)
return false;
agentLockPassphrase = lockPassphrase;
return true;
}
/* (non-Javadoc)
* @see org.connectbot.transport.AbsTransport#usesNetwork()
*/
@Override
public boolean usesNetwork() {
return true;
}
}
| 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.transport;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.connectbot.bean.HostBean;
import org.connectbot.bean.PortForwardBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import android.content.Context;
import android.net.Uri;
/**
* @author Kenny Root
*
*/
public abstract class AbsTransport {
HostBean host;
TerminalBridge bridge;
TerminalManager manager;
String emulation;
public AbsTransport() {}
public AbsTransport(HostBean host, TerminalBridge bridge, TerminalManager manager) {
this.host = host;
this.bridge = bridge;
this.manager = manager;
}
/**
* @return protocol part of the URI
*/
public static String getProtocolName() {
return "unknown";
}
/**
* Encode the current transport into a URI that can be passed via intent calls.
* @return URI to host
*/
public static Uri getUri(String input) {
return null;
}
/**
* Causes transport to connect to the target host. After connecting but before a
* session is started, must call back to {@link TerminalBridge#onConnected()}.
* After that call a session may be opened.
*/
public abstract void connect();
/**
* Reads from the transport. Transport must support reading into a the byte array
* <code>buffer</code> at the start of <code>offset</code> and a maximum of
* <code>length</code> bytes. If the remote host disconnects, throw an
* {@link IOException}.
* @param buffer byte buffer to store read bytes into
* @param offset where to start writing in the buffer
* @param length maximum number of bytes to read
* @return number of bytes read
* @throws IOException when remote host disconnects
*/
public abstract int read(byte[] buffer, int offset, int length) throws IOException;
/**
* Writes to the transport. If the host is not yet connected, simply return without
* doing anything. An {@link IOException} should be thrown if there is an error after
* connection.
* @param buffer bytes to write to transport
* @throws IOException when there is a problem writing after connection
*/
public abstract void write(byte[] buffer) throws IOException;
/**
* Writes to the transport. See {@link #write(byte[])} for behavior details.
* @param c character to write to the transport
* @throws IOException when there is a problem writing after connection
*/
public abstract void write(int c) throws IOException;
/**
* Flushes the write commands to the transport.
* @throws IOException when there is a problem writing after connection
*/
public abstract void flush() throws IOException;
/**
* Closes the connection to the terminal. Note that the resulting failure to read
* should call {@link TerminalBridge#dispatchDisconnect(boolean)}.
*/
public abstract void close();
/**
* Tells the transport what dimensions the display is currently
* @param columns columns of text
* @param rows rows of text
* @param width width in pixels
* @param height height in pixels
*/
public abstract void setDimensions(int columns, int rows, int width, int height);
public void setOptions(Map<String,String> options) {
// do nothing
}
public Map<String,String> getOptions() {
return null;
}
public void setCompression(boolean compression) {
// do nothing
}
public void setUseAuthAgent(String useAuthAgent) {
// do nothing
}
public void setEmulation(String emulation) {
this.emulation = emulation;
}
public String getEmulation() {
return emulation;
}
public void setHost(HostBean host) {
this.host = host;
}
public void setBridge(TerminalBridge bridge) {
this.bridge = bridge;
}
public void setManager(TerminalManager manager) {
this.manager = manager;
}
/**
* Whether or not this transport type can forward ports.
* @return true on ability to forward ports
*/
public boolean canForwardPorts() {
return false;
}
/**
* Adds the {@link PortForwardBean} to the list.
* @param portForward the port forward bean to add
* @return true on successful addition
*/
public boolean addPortForward(PortForwardBean portForward) {
return false;
}
/**
* Enables a port forward member. After calling this method, the port forward should
* be operational iff it could be enabled by the transport.
* @param portForward member of our current port forwards list to enable
* @return true on successful port forward setup
*/
public boolean enablePortForward(PortForwardBean portForward) {
return false;
}
/**
* Disables a port forward member. After calling this method, the port forward should
* be non-functioning iff it could be disabled by the transport.
* @param portForward member of our current port forwards list to enable
* @return true on successful port forward tear-down
*/
public boolean disablePortForward(PortForwardBean portForward) {
return false;
}
/**
* Removes the {@link PortForwardBean} from the available port forwards.
* @param portForward the port forward bean to remove
* @return true on successful removal
*/
public boolean removePortForward(PortForwardBean portForward) {
return false;
}
/**
* Gets a list of the {@link PortForwardBean} currently used by this transport.
* @return the list of port forwards
*/
public List<PortForwardBean> getPortForwards() {
return null;
}
public abstract boolean isConnected();
public abstract boolean isSessionOpen();
/**
* @return int default port for protocol
*/
public abstract int getDefaultPort();
/**
* @param username
* @param hostname
* @param port
* @return
*/
public abstract String getDefaultNickname(String username, String hostname, int port);
/**
* @param uri
* @param selectionKeys
* @param selectionValues
*/
public abstract void getSelectionArgs(Uri uri, Map<String, String> selection);
/**
* @param uri
* @return
*/
public abstract HostBean createHost(Uri uri);
/**
* @param context context containing the correct resources
* @return string that hints at the format for connection
*/
public static String getFormatHint(Context context) {
return "???";
}
/**
* @return
*/
public abstract boolean usesNetwork();
}
| 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.transport;
import java.util.HashMap;
import java.util.Map;
import org.connectbot.bean.HostBean;
import org.connectbot.util.HostDatabase;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
/**
* @author Kenny Root
*
*/
public class TransportFactory {
private static final String TAG = "ConnectBot.TransportFactory";
private static String[] transportNames = {
SSH.getProtocolName(),
Telnet.getProtocolName(),
Local.getProtocolName(),
};
/**
* @param protocol
* @return
*/
public static AbsTransport getTransport(String protocol) {
if (SSH.getProtocolName().equals(protocol)) {
return new SSH();
} else if (Telnet.getProtocolName().equals(protocol)) {
return new Telnet();
} else if (Local.getProtocolName().equals(protocol)) {
return new Local();
} else {
return null;
}
}
public static Uri getUri(String scheme, String input) {
Log.d("TransportFactory", String.format(
"Attempting to discover URI for scheme=%s on input=%s", scheme,
input));
if (SSH.getProtocolName().equals(scheme))
return SSH.getUri(input);
else if (Telnet.getProtocolName().equals(scheme))
return Telnet.getUri(input);
else if (Local.getProtocolName().equals(scheme)) {
Log.d("TransportFactory", "Got to the local parsing area");
return Local.getUri(input);
} else
return null;
}
public static String[] getTransportNames() {
return transportNames;
}
public static boolean isSameTransportType(AbsTransport a, AbsTransport b) {
if (a == null || b == null)
return false;
return a.getClass().equals(b.getClass());
}
public static boolean canForwardPorts(String protocol) {
// TODO uh, make this have less knowledge about its children
if (SSH.getProtocolName().equals(protocol)) {
return true;
} else {
return false;
}
}
/**
* @param protocol text name of protocol
* @param context
* @return expanded format hint
*/
public static String getFormatHint(String protocol, Context context) {
if (SSH.getProtocolName().equals(protocol)) {
return SSH.getFormatHint(context);
} else if (Telnet.getProtocolName().equals(protocol)) {
return Telnet.getFormatHint(context);
} else if (Local.getProtocolName().equals(protocol)) {
return Local.getFormatHint(context);
} else {
return AbsTransport.getFormatHint(context);
}
}
/**
* @param hostdb Handle to HostDatabase
* @param uri URI to target server
* @param host HostBean in which to put the results
* @return true when host was found
*/
public static HostBean findHost(HostDatabase hostdb, Uri uri) {
AbsTransport transport = getTransport(uri.getScheme());
Map<String, String> selection = new HashMap<String, String>();
transport.getSelectionArgs(uri, selection);
if (selection.size() == 0) {
Log.e(TAG, String.format("Transport %s failed to do something useful with URI=%s",
uri.getScheme(), uri.toString()));
throw new IllegalStateException("Failed to get needed selection arguments");
}
return hostdb.findHost(selection);
}
}
| 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.transport;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.connectbot.R;
import org.connectbot.bean.HostBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import org.connectbot.util.HostDatabase;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
import de.mud.telnet.TelnetProtocolHandler;
/**
* Telnet transport implementation.<br/>
* Original idea from the JTA telnet package (de.mud.telnet)
*
* @author Kenny Root
*
*/
public class Telnet extends AbsTransport {
private static final String TAG = "ConnectBot.Telnet";
private static final String PROTOCOL = "telnet";
private static final int DEFAULT_PORT = 23;
private TelnetProtocolHandler handler;
private Socket socket;
private InputStream is;
private OutputStream os;
private int width;
private int height;
private boolean connected = false;
static final Pattern hostmask;
static {
hostmask = Pattern.compile("^([0-9a-z.-]+)(:(\\d+))?$", Pattern.CASE_INSENSITIVE);
}
public Telnet() {
handler = new TelnetProtocolHandler() {
/** get the current terminal type */
@Override
public String getTerminalType() {
return getEmulation();
}
/** get the current window size */
@Override
public int[] getWindowSize() {
return new int[] { width, height };
}
/** notify about local echo */
@Override
public void setLocalEcho(boolean echo) {
/* EMPTY */
}
/** write data to our back end */
@Override
public void write(byte[] b) throws IOException {
if (os != null)
os.write(b);
}
/** sent on IAC EOR (prompt terminator for remote access systems). */
@Override
public void notifyEndOfRecord() {
}
@Override
protected String getCharsetName() {
Charset charset = bridge.getCharset();
if (charset != null)
return charset.name();
else
return "";
}
};
}
/**
* @param host
* @param bridge
* @param manager
*/
public Telnet(HostBean host, TerminalBridge bridge, TerminalManager manager) {
super(host, bridge, manager);
}
public static String getProtocolName() {
return PROTOCOL;
}
@Override
public void connect() {
try {
socket = new Socket(host.getHostname(), host.getPort());
connected = true;
is = socket.getInputStream();
os = socket.getOutputStream();
bridge.onConnected();
} catch (UnknownHostException e) {
Log.d(TAG, "IO Exception connecting to host", e);
} catch (IOException e) {
Log.d(TAG, "IO Exception connecting to host", e);
}
}
@Override
public void close() {
connected = false;
if (socket != null)
try {
socket.close();
socket = null;
} catch (IOException e) {
Log.d(TAG, "Error closing telnet socket.", e);
}
}
@Override
public void flush() throws IOException {
os.flush();
}
@Override
public int getDefaultPort() {
return DEFAULT_PORT;
}
@Override
public boolean isConnected() {
return connected;
}
@Override
public boolean isSessionOpen() {
return connected;
}
@Override
public int read(byte[] buffer, int start, int len) throws IOException {
/* process all already read bytes */
int n = 0;
do {
n = handler.negotiate(buffer, start);
if (n > 0)
return n;
} while (n == 0);
while (n <= 0) {
do {
n = handler.negotiate(buffer, start);
if (n > 0)
return n;
} while (n == 0);
n = is.read(buffer, start, len);
if (n < 0) {
bridge.dispatchDisconnect(false);
throw new IOException("Remote end closed connection.");
}
handler.inputfeed(buffer, start, n);
n = handler.negotiate(buffer, start);
}
return n;
}
@Override
public void write(byte[] buffer) throws IOException {
try {
if (os != null)
os.write(buffer);
} catch (SocketException e) {
bridge.dispatchDisconnect(false);
}
}
@Override
public void write(int c) throws IOException {
try {
if (os != null)
os.write(c);
} catch (SocketException e) {
bridge.dispatchDisconnect(false);
}
}
@Override
public void setDimensions(int columns, int rows, int width, int height) {
try {
handler.setWindowSize(columns, rows);
} catch (IOException e) {
Log.e(TAG, "Couldn't resize remote terminal", e);
}
}
@Override
public String getDefaultNickname(String username, String hostname, int port) {
if (port == DEFAULT_PORT) {
return String.format("%s", hostname);
} else {
return String.format("%s:%d", hostname, port);
}
}
public static Uri getUri(String input) {
Matcher matcher = hostmask.matcher(input);
if (!matcher.matches())
return null;
StringBuilder sb = new StringBuilder();
sb.append(PROTOCOL)
.append("://")
.append(matcher.group(1));
String portString = matcher.group(3);
int port = DEFAULT_PORT;
if (portString != null) {
try {
port = Integer.parseInt(portString);
if (port < 1 || port > 65535) {
port = DEFAULT_PORT;
}
} catch (NumberFormatException nfe) {
// Keep the default port
}
}
if (port != DEFAULT_PORT) {
sb.append(':');
sb.append(port);
}
sb.append("/#")
.append(Uri.encode(input));
Uri uri = Uri.parse(sb.toString());
return uri;
}
@Override
public HostBean createHost(Uri uri) {
HostBean host = new HostBean();
host.setProtocol(PROTOCOL);
host.setHostname(uri.getHost());
int port = uri.getPort();
if (port < 0)
port = DEFAULT_PORT;
host.setPort(port);
String nickname = uri.getFragment();
if (nickname == null || nickname.length() == 0) {
host.setNickname(getDefaultNickname(host.getUsername(),
host.getHostname(), host.getPort()));
} else {
host.setNickname(uri.getFragment());
}
return host;
}
@Override
public void getSelectionArgs(Uri uri, Map<String, String> selection) {
selection.put(HostDatabase.FIELD_HOST_PROTOCOL, PROTOCOL);
selection.put(HostDatabase.FIELD_HOST_NICKNAME, uri.getFragment());
selection.put(HostDatabase.FIELD_HOST_HOSTNAME, uri.getHost());
int port = uri.getPort();
if (port < 0)
port = DEFAULT_PORT;
selection.put(HostDatabase.FIELD_HOST_PORT, Integer.toString(port));
}
public static String getFormatHint(Context context) {
return String.format("%s:%s",
context.getString(R.string.format_hostname),
context.getString(R.string.format_port));
}
/* (non-Javadoc)
* @see org.connectbot.transport.AbsTransport#usesNetwork()
*/
@Override
public boolean usesNetwork() {
return true;
}
}
| 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.transport;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Map;
import org.connectbot.R;
import org.connectbot.bean.HostBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import org.connectbot.util.HostDatabase;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
import com.google.ase.Exec;
/**
* @author Kenny Root
*
*/
public class Local extends AbsTransport {
private static final String TAG = "ConnectBot.Local";
private static final String PROTOCOL = "local";
private static final String DEFAULT_URI = "local:#Local";
private FileDescriptor shellFd;
private FileInputStream is;
private FileOutputStream os;
/**
*
*/
public Local() {
}
/**
* @param host
* @param bridge
* @param manager
*/
public Local(HostBean host, TerminalBridge bridge, TerminalManager manager) {
super(host, bridge, manager);
}
public static String getProtocolName() {
return PROTOCOL;
}
@Override
public void close() {
try {
if (os != null) {
os.close();
os = null;
}
if (is != null) {
is.close();
is = null;
}
} catch (IOException e) {
Log.e(TAG, "Couldn't close shell", e);
}
}
@Override
public void connect() {
int[] pids = new int[1];
try {
shellFd = Exec.createSubprocess("/system/bin/sh", "-", null, pids);
} catch (Exception e) {
bridge.outputLine(manager.res.getString(R.string.local_shell_unavailable));
Log.e(TAG, "Cannot start local shell", e);
return;
}
final int shellPid = pids[0];
Runnable exitWatcher = new Runnable() {
public void run() {
Exec.waitFor(shellPid);
bridge.dispatchDisconnect(false);
}
};
Thread exitWatcherThread = new Thread(exitWatcher);
exitWatcherThread.setName("LocalExitWatcher");
exitWatcherThread.setDaemon(true);
exitWatcherThread.start();
is = new FileInputStream(shellFd);
os = new FileOutputStream(shellFd);
bridge.onConnected();
}
@Override
public void flush() throws IOException {
os.flush();
}
@Override
public String getDefaultNickname(String username, String hostname, int port) {
return DEFAULT_URI;
}
@Override
public int getDefaultPort() {
return 0;
}
@Override
public boolean isConnected() {
return is != null && os != null;
}
@Override
public boolean isSessionOpen() {
return is != null && os != null;
}
@Override
public int read(byte[] buffer, int start, int len) throws IOException {
if (is == null) {
bridge.dispatchDisconnect(false);
throw new IOException("session closed");
}
return is.read(buffer, start, len);
}
@Override
public void setDimensions(int columns, int rows, int width, int height) {
try {
Exec.setPtyWindowSize(shellFd, rows, columns, width, height);
} catch (Exception e) {
Log.e(TAG, "Couldn't resize pty", e);
}
}
@Override
public void write(byte[] buffer) throws IOException {
if (os != null)
os.write(buffer);
}
@Override
public void write(int c) throws IOException {
if (os != null)
os.write(c);
}
public static Uri getUri(String input) {
Uri uri = Uri.parse(DEFAULT_URI);
if (input != null && input.length() > 0) {
uri = uri.buildUpon().fragment(input).build();
}
return uri;
}
@Override
public HostBean createHost(Uri uri) {
HostBean host = new HostBean();
host.setProtocol(PROTOCOL);
String nickname = uri.getFragment();
if (nickname == null || nickname.length() == 0) {
host.setNickname(getDefaultNickname(host.getUsername(),
host.getHostname(), host.getPort()));
} else {
host.setNickname(uri.getFragment());
}
return host;
}
@Override
public void getSelectionArgs(Uri uri, Map<String, String> selection) {
selection.put(HostDatabase.FIELD_HOST_PROTOCOL, PROTOCOL);
selection.put(HostDatabase.FIELD_HOST_NICKNAME, uri.getFragment());
}
public static String getFormatHint(Context context) {
return context.getString(R.string.hostpref_nickname_title);
}
/* (non-Javadoc)
* @see org.connectbot.transport.AbsTransport#usesNetwork()
*/
@Override
public boolean usesNetwork() {
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;
import android.os.StrictMode;
public class StrictModeSetup {
public static void run() {
StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.LAX);
}
}
| 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 java.util.List;
import org.connectbot.bean.HostBean;
import org.connectbot.service.TerminalBridge;
import org.connectbot.service.TerminalManager;
import org.connectbot.transport.TransportFactory;
import org.connectbot.util.HostDatabase;
import org.connectbot.util.PreferenceConstants;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.ListActivity;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.Intent.ShortcutIconResource;
import android.content.SharedPreferences.Editor;
import android.content.res.ColorStateList;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.ContextMenu;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.View.OnKeyListener;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.AdapterView.OnItemClickListener;
public class HostListActivity extends ListActivity {
public final static int REQUEST_EDIT = 1;
public final static int REQUEST_EULA = 2;
protected TerminalManager bound = null;
protected HostDatabase hostdb;
private List<HostBean> hosts;
protected LayoutInflater inflater = null;
protected boolean sortedByColor = false;
private MenuItem sortcolor;
private MenuItem sortlast;
private Spinner transportSpinner;
private TextView quickconnect;
private SharedPreferences prefs = null;
protected boolean makingShortcut = false;
protected Handler updateHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
HostListActivity.this.updateList();
}
};
private ServiceConnection connection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
bound = ((TerminalManager.TerminalBinder) service).getService();
// update our listview binder to find the service
HostListActivity.this.updateList();
}
public void onServiceDisconnected(ComponentName className) {
bound = null;
HostListActivity.this.updateList();
}
};
@Override
public void onStart() {
super.onStart();
// start the terminal manager service
this.bindService(new Intent(this, TerminalManager.class), connection, Context.BIND_AUTO_CREATE);
if(this.hostdb == null)
this.hostdb = new HostDatabase(this);
}
@Override
public void onStop() {
super.onStop();
this.unbindService(connection);
if(this.hostdb != null) {
this.hostdb.close();
this.hostdb = null;
}
}
@Override
public void onResume() {
super.onResume();
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUEST_EULA) {
if(resultCode == Activity.RESULT_OK) {
// yay they agreed, so store that info
Editor edit = prefs.edit();
edit.putBoolean(PreferenceConstants.EULA, true);
edit.commit();
} else {
// user didnt agree, so close
this.finish();
}
} else if (requestCode == REQUEST_EDIT) {
this.updateList();
}
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.act_hostlist);
this.setTitle(String.format("%s: %s",
getResources().getText(R.string.app_name),
getResources().getText(R.string.title_hosts_list)));
// check for eula agreement
this.prefs = PreferenceManager.getDefaultSharedPreferences(this);
boolean agreed = prefs.getBoolean(PreferenceConstants.EULA, false);
if(!agreed) {
this.startActivityForResult(new Intent(this, WizardActivity.class), REQUEST_EULA);
}
this.makingShortcut = Intent.ACTION_CREATE_SHORTCUT.equals(getIntent().getAction())
|| Intent.ACTION_PICK.equals(getIntent().getAction());
// connect with hosts database and populate list
this.hostdb = new HostDatabase(this);
ListView list = this.getListView();
this.sortedByColor = prefs.getBoolean(PreferenceConstants.SORT_BY_COLOR, false);
//this.list.setSelector(R.drawable.highlight_disabled_pressed);
list.setOnItemClickListener(new OnItemClickListener() {
public synchronized void onItemClick(AdapterView<?> parent, View view, int position, long id) {
// launch off to console details
HostBean host = (HostBean) parent.getAdapter().getItem(position);
Uri uri = host.getUri();
Intent contents = new Intent(Intent.ACTION_VIEW, uri);
contents.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
if (makingShortcut) {
// create shortcut if requested
ShortcutIconResource icon = Intent.ShortcutIconResource.fromContext(HostListActivity.this, R.drawable.icon);
Intent intent = new Intent();
intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, contents);
intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, host.getNickname());
intent.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, icon);
setResult(RESULT_OK, intent);
finish();
} else {
// otherwise just launch activity to show this host
HostListActivity.this.startActivity(contents);
}
}
});
this.registerForContextMenu(list);
quickconnect = (TextView) this.findViewById(R.id.front_quickconnect);
quickconnect.setVisibility(makingShortcut ? View.GONE : View.VISIBLE);
quickconnect.setOnKeyListener(new OnKeyListener() {
public boolean onKey(View v, int keyCode, KeyEvent event) {
if(event.getAction() == KeyEvent.ACTION_UP) return false;
if(keyCode != KeyEvent.KEYCODE_ENTER) return false;
return startConsoleActivity();
}
});
transportSpinner = (Spinner)findViewById(R.id.transport_selection);
transportSpinner.setVisibility(makingShortcut ? View.GONE : View.VISIBLE);
ArrayAdapter<String> transportSelection = new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_item, TransportFactory.getTransportNames());
transportSelection.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
transportSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> arg0, View view, int position, long id) {
String formatHint = TransportFactory.getFormatHint(
(String) transportSpinner.getSelectedItem(),
HostListActivity.this);
quickconnect.setHint(formatHint);
quickconnect.setError(null);
quickconnect.requestFocus();
}
public void onNothingSelected(AdapterView<?> arg0) { }
});
transportSpinner.setAdapter(transportSelection);
this.inflater = LayoutInflater.from(this);
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
// don't offer menus when creating shortcut
if (makingShortcut) return true;
sortcolor.setVisible(!sortedByColor);
sortlast.setVisible(sortedByColor);
return true;
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
// don't offer menus when creating shortcut
if(makingShortcut) return true;
// add host, ssh keys, about
sortcolor = menu.add(R.string.list_menu_sortcolor);
sortcolor.setIcon(android.R.drawable.ic_menu_share);
sortcolor.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
sortedByColor = true;
updateList();
return true;
}
});
sortlast = menu.add(R.string.list_menu_sortname);
sortlast.setIcon(android.R.drawable.ic_menu_share);
sortlast.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
sortedByColor = false;
updateList();
return true;
}
});
MenuItem keys = menu.add(R.string.list_menu_pubkeys);
keys.setIcon(android.R.drawable.ic_lock_lock);
keys.setIntent(new Intent(HostListActivity.this, PubkeyListActivity.class));
MenuItem colors = menu.add("Colors");
colors.setIcon(android.R.drawable.ic_menu_slideshow);
colors.setIntent(new Intent(HostListActivity.this, ColorsActivity.class));
MenuItem settings = menu.add(R.string.list_menu_settings);
settings.setIcon(android.R.drawable.ic_menu_preferences);
settings.setIntent(new Intent(HostListActivity.this, SettingsActivity.class));
MenuItem help = menu.add(R.string.title_help);
help.setIcon(android.R.drawable.ic_menu_help);
help.setIntent(new Intent(HostListActivity.this, HelpActivity.class));
return true;
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
// create menu to handle hosts
// create menu to handle deleting and sharing lists
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo;
final HostBean host = (HostBean) this.getListView().getItemAtPosition(info.position);
menu.setHeaderTitle(host.getNickname());
// edit, disconnect, delete
MenuItem connect = menu.add(R.string.list_host_disconnect);
final TerminalBridge bridge = bound.getConnectedBridge(host);
connect.setEnabled((bridge != null));
connect.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
bridge.dispatchDisconnect(true);
updateHandler.sendEmptyMessage(-1);
return true;
}
});
MenuItem edit = menu.add(R.string.list_host_edit);
edit.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
Intent intent = new Intent(HostListActivity.this, HostEditorActivity.class);
intent.putExtra(Intent.EXTRA_TITLE, host.getId());
HostListActivity.this.startActivityForResult(intent, REQUEST_EDIT);
return true;
}
});
MenuItem portForwards = menu.add(R.string.list_host_portforwards);
portForwards.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
Intent intent = new Intent(HostListActivity.this, PortForwardListActivity.class);
intent.putExtra(Intent.EXTRA_TITLE, host.getId());
HostListActivity.this.startActivityForResult(intent, REQUEST_EDIT);
return true;
}
});
if (!TransportFactory.canForwardPorts(host.getProtocol()))
portForwards.setEnabled(false);
MenuItem delete = menu.add(R.string.list_host_delete);
delete.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// prompt user to make sure they really want this
new AlertDialog.Builder(HostListActivity.this)
.setMessage(getString(R.string.delete_message, host.getNickname()))
.setPositiveButton(R.string.delete_pos, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
// make sure we disconnect
if(bridge != null)
bridge.dispatchDisconnect(true);
hostdb.deleteHost(host);
updateHandler.sendEmptyMessage(-1);
}
})
.setNegativeButton(R.string.delete_neg, null).create().show();
return true;
}
});
}
/**
* @param text
* @return
*/
private boolean startConsoleActivity() {
Uri uri = TransportFactory.getUri((String) transportSpinner
.getSelectedItem(), quickconnect.getText().toString());
if (uri == null) {
quickconnect.setError(getString(R.string.list_format_error,
TransportFactory.getFormatHint(
(String) transportSpinner.getSelectedItem(),
HostListActivity.this)));
return false;
}
HostBean host = TransportFactory.findHost(hostdb, uri);
if (host == null) {
host = TransportFactory.getTransport(uri.getScheme()).createHost(uri);
host.setColor(HostDatabase.COLOR_GRAY);
host.setPubkeyId(HostDatabase.PUBKEYID_ANY);
hostdb.saveHost(host);
}
Intent intent = new Intent(HostListActivity.this, ConsoleActivity.class);
intent.setData(uri);
startActivity(intent);
return true;
}
protected void updateList() {
if (prefs.getBoolean(PreferenceConstants.SORT_BY_COLOR, false) != sortedByColor) {
Editor edit = prefs.edit();
edit.putBoolean(PreferenceConstants.SORT_BY_COLOR, sortedByColor);
edit.commit();
}
if (hostdb == null)
hostdb = new HostDatabase(this);
hosts = hostdb.getHosts(sortedByColor);
// Don't lose hosts that are connected via shortcuts but not in the database.
if (bound != null) {
for (TerminalBridge bridge : bound.bridges) {
if (!hosts.contains(bridge.host))
hosts.add(0, bridge.host);
}
}
HostAdapter adapter = new HostAdapter(this, hosts, bound);
this.setListAdapter(adapter);
}
class HostAdapter extends ArrayAdapter<HostBean> {
private List<HostBean> hosts;
private final TerminalManager manager;
private final ColorStateList red, green, blue;
public final static int STATE_UNKNOWN = 1, STATE_CONNECTED = 2, STATE_DISCONNECTED = 3;
class ViewHolder {
public TextView nickname;
public TextView caption;
public ImageView icon;
}
public HostAdapter(Context context, List<HostBean> hosts, TerminalManager manager) {
super(context, R.layout.item_host, hosts);
this.hosts = hosts;
this.manager = manager;
red = context.getResources().getColorStateList(R.color.red);
green = context.getResources().getColorStateList(R.color.green);
blue = context.getResources().getColorStateList(R.color.blue);
}
/**
* Check if we're connected to a terminal with the given host.
*/
private int getConnectedState(HostBean host) {
// always disconnected if we dont have backend service
if (this.manager == null)
return STATE_UNKNOWN;
if (manager.getConnectedBridge(host) != null)
return STATE_CONNECTED;
if (manager.disconnected.contains(host))
return STATE_DISCONNECTED;
return STATE_UNKNOWN;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (convertView == null) {
convertView = inflater.inflate(R.layout.item_host, null, false);
holder = new ViewHolder();
holder.nickname = (TextView)convertView.findViewById(android.R.id.text1);
holder.caption = (TextView)convertView.findViewById(android.R.id.text2);
holder.icon = (ImageView)convertView.findViewById(android.R.id.icon);
convertView.setTag(holder);
} else
holder = (ViewHolder) convertView.getTag();
HostBean host = hosts.get(position);
if (host == null) {
// Well, something bad happened. We can't continue.
Log.e("HostAdapter", "Host bean is null!");
holder.nickname.setText("Error during lookup");
holder.caption.setText("see 'adb logcat' for more");
return convertView;
}
holder.nickname.setText(host.getNickname());
switch (this.getConnectedState(host)) {
case STATE_UNKNOWN:
holder.icon.setImageState(new int[] { }, true);
break;
case STATE_CONNECTED:
holder.icon.setImageState(new int[] { android.R.attr.state_checked }, true);
break;
case STATE_DISCONNECTED:
holder.icon.setImageState(new int[] { android.R.attr.state_expanded }, true);
break;
}
ColorStateList chosen = null;
if (HostDatabase.COLOR_RED.equals(host.getColor()))
chosen = this.red;
else if (HostDatabase.COLOR_GREEN.equals(host.getColor()))
chosen = this.green;
else if (HostDatabase.COLOR_BLUE.equals(host.getColor()))
chosen = this.blue;
Context context = convertView.getContext();
if (chosen != null) {
// set color normally if not selected
holder.nickname.setTextColor(chosen);
holder.caption.setTextColor(chosen);
} else {
// selected, so revert back to default black text
holder.nickname.setTextAppearance(context, android.R.attr.textAppearanceLarge);
holder.caption.setTextAppearance(context, android.R.attr.textAppearanceSmall);
}
long now = System.currentTimeMillis() / 1000;
String nice = context.getString(R.string.bind_never);
if (host.getLastConnect() > 0) {
int minutes = (int)((now - host.getLastConnect()) / 60);
if (minutes >= 60) {
int hours = (minutes / 60);
if (hours >= 24) {
int days = (hours / 24);
nice = context.getString(R.string.bind_days, days);
} else
nice = context.getString(R.string.bind_hours, hours);
} else
nice = context.getString(R.string.bind_minutes, minutes);
}
holder.caption.setText(nice);
return convertView;
}
}
}
| 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 java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Collections;
import java.util.EventListener;
import java.util.LinkedList;
import java.util.List;
import org.connectbot.bean.PubkeyBean;
import org.connectbot.service.TerminalManager;
import org.connectbot.util.PubkeyDatabase;
import org.connectbot.util.PubkeyUtils;
import org.openintents.intents.FileManagerIntents;
import android.app.AlertDialog;
import android.app.ListActivity;
import android.content.ActivityNotFoundException;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.ServiceConnection;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.text.ClipboardManager;
import android.util.Log;
import android.view.ContextMenu;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TableRow;
import android.widget.TextView;
import android.widget.Toast;
import com.trilead.ssh2.crypto.Base64;
import com.trilead.ssh2.crypto.PEMDecoder;
import com.trilead.ssh2.crypto.PEMStructure;
/**
* List public keys in database by nickname and describe their properties. Allow users to import,
* generate, rename, and delete key pairs.
*
* @author Kenny Root
*/
public class PubkeyListActivity extends ListActivity implements EventListener {
public final static String TAG = "ConnectBot.PubkeyListActivity";
private static final int MAX_KEYFILE_SIZE = 8192;
private static final int REQUEST_CODE_PICK_FILE = 1;
// Constants for AndExplorer's file picking intent
private static final String ANDEXPLORER_TITLE = "explorer_title";
private static final String MIME_TYPE_ANDEXPLORER_FILE = "vnd.android.cursor.dir/lysesoft.andexplorer.file";
protected PubkeyDatabase pubkeydb;
private List<PubkeyBean> pubkeys;
protected ClipboardManager clipboard;
protected LayoutInflater inflater = null;
protected TerminalManager bound = null;
private MenuItem onstartToggle = null;
private MenuItem confirmUse = null;
private ServiceConnection connection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
bound = ((TerminalManager.TerminalBinder) service).getService();
// update our listview binder to find the service
updateList();
}
public void onServiceDisconnected(ComponentName className) {
bound = null;
updateList();
}
};
@Override
public void onStart() {
super.onStart();
bindService(new Intent(this, TerminalManager.class), connection, Context.BIND_AUTO_CREATE);
if(pubkeydb == null)
pubkeydb = new PubkeyDatabase(this);
}
@Override
public void onStop() {
super.onStop();
unbindService(connection);
if(pubkeydb != null) {
pubkeydb.close();
pubkeydb = null;
}
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.act_pubkeylist);
this.setTitle(String.format("%s: %s",
getResources().getText(R.string.app_name),
getResources().getText(R.string.title_pubkey_list)));
// connect with hosts database and populate list
pubkeydb = new PubkeyDatabase(this);
updateList();
registerForContextMenu(getListView());
getListView().setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> adapter, View view, int position, long id) {
PubkeyBean pubkey = (PubkeyBean) getListView().getItemAtPosition(position);
boolean loaded = bound.isKeyLoaded(pubkey.getNickname());
// handle toggling key in-memory on/off
if(loaded) {
bound.removeKey(pubkey.getNickname());
updateHandler.sendEmptyMessage(-1);
} else {
handleAddKey(pubkey);
}
}
});
clipboard = (ClipboardManager)getSystemService(CLIPBOARD_SERVICE);
inflater = LayoutInflater.from(this);
}
/**
* Read given file into memory as <code>byte[]</code>.
*/
protected static byte[] readRaw(File file) throws Exception {
InputStream is = new FileInputStream(file);
ByteArrayOutputStream os = new ByteArrayOutputStream();
int bytesRead;
byte[] buffer = new byte[1024];
while ((bytesRead = is.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
}
os.flush();
os.close();
is.close();
return os.toByteArray();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
MenuItem generatekey = menu.add(R.string.pubkey_generate);
generatekey.setIcon(android.R.drawable.ic_menu_manage);
generatekey.setIntent(new Intent(PubkeyListActivity.this, GeneratePubkeyActivity.class));
MenuItem importkey = menu.add(R.string.pubkey_import);
importkey.setIcon(android.R.drawable.ic_menu_upload);
importkey.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
Uri sdcard = Uri.fromFile(Environment.getExternalStorageDirectory());
String pickerTitle = getString(R.string.pubkey_list_pick);
// Try to use OpenIntent's file browser to pick a file
Intent intent = new Intent(FileManagerIntents.ACTION_PICK_FILE);
intent.setData(sdcard);
intent.putExtra(FileManagerIntents.EXTRA_TITLE, pickerTitle);
intent.putExtra(FileManagerIntents.EXTRA_BUTTON_TEXT, getString(android.R.string.ok));
try {
startActivityForResult(intent, REQUEST_CODE_PICK_FILE);
} catch (ActivityNotFoundException e) {
// If OI didn't work, try AndExplorer
intent = new Intent(Intent.ACTION_PICK);
intent.setDataAndType(sdcard, MIME_TYPE_ANDEXPLORER_FILE);
intent.putExtra(ANDEXPLORER_TITLE, pickerTitle);
try {
startActivityForResult(intent, REQUEST_CODE_PICK_FILE);
} catch (ActivityNotFoundException e1) {
pickFileSimple();
}
}
return true;
}
});
return true;
}
protected void handleAddKey(final PubkeyBean pubkey) {
if (pubkey.isEncrypted()) {
final View view = inflater.inflate(R.layout.dia_password, null);
final EditText passwordField = (EditText)view.findViewById(android.R.id.text1);
new AlertDialog.Builder(PubkeyListActivity.this)
.setView(view)
.setPositiveButton(R.string.pubkey_unlock, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
handleAddKey(pubkey, passwordField.getText().toString());
}
})
.setNegativeButton(android.R.string.cancel, null).create().show();
} else {
handleAddKey(pubkey, null);
}
}
protected void handleAddKey(PubkeyBean pubkey, String password) {
Object trileadKey = null;
if(PubkeyDatabase.KEY_TYPE_IMPORTED.equals(pubkey.getType())) {
// load specific key using pem format
try {
trileadKey = PEMDecoder.decode(new String(pubkey.getPrivateKey()).toCharArray(), password);
} catch(Exception e) {
String message = getResources().getString(R.string.pubkey_failed_add, pubkey.getNickname());
Log.e(TAG, message, e);
Toast.makeText(PubkeyListActivity.this, message, Toast.LENGTH_LONG);
}
} else {
// load using internal generated format
PrivateKey privKey = null;
PublicKey pubKey = null;
try {
privKey = PubkeyUtils.decodePrivate(pubkey.getPrivateKey(), pubkey.getType(), password);
pubKey = pubkey.getPublicKey();
} catch (Exception e) {
String message = getResources().getString(R.string.pubkey_failed_add, pubkey.getNickname());
Log.e(TAG, message, e);
Toast.makeText(PubkeyListActivity.this, message, Toast.LENGTH_LONG);
return;
}
// convert key to trilead format
trileadKey = PubkeyUtils.convertToTrilead(privKey, pubKey);
Log.d(TAG, "Unlocked key " + PubkeyUtils.formatKey(pubKey));
}
if(trileadKey == null) return;
Log.d(TAG, String.format("Unlocked key '%s'", pubkey.getNickname()));
// save this key in memory
bound.addKey(pubkey, trileadKey, true);
updateHandler.sendEmptyMessage(-1);
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
// Create menu to handle deleting and editing pubkey
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo;
final PubkeyBean pubkey = (PubkeyBean) getListView().getItemAtPosition(info.position);
menu.setHeaderTitle(pubkey.getNickname());
// TODO: option load/unload key from in-memory list
// prompt for password as needed for passworded keys
// cant change password or clipboard imported keys
final boolean imported = PubkeyDatabase.KEY_TYPE_IMPORTED.equals(pubkey.getType());
final boolean loaded = bound.isKeyLoaded(pubkey.getNickname());
MenuItem load = menu.add(loaded ? R.string.pubkey_memory_unload : R.string.pubkey_memory_load);
load.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
if(loaded) {
bound.removeKey(pubkey.getNickname());
updateHandler.sendEmptyMessage(-1);
} else {
handleAddKey(pubkey);
//bound.addKey(nickname, trileadKey);
}
return true;
}
});
onstartToggle = menu.add(R.string.pubkey_load_on_start);
onstartToggle.setEnabled(!pubkey.isEncrypted());
onstartToggle.setCheckable(true);
onstartToggle.setChecked(pubkey.isStartup());
onstartToggle.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// toggle onstart status
pubkey.setStartup(!pubkey.isStartup());
pubkeydb.savePubkey(pubkey);
updateHandler.sendEmptyMessage(-1);
return true;
}
});
MenuItem copyPublicToClipboard = menu.add(R.string.pubkey_copy_public);
copyPublicToClipboard.setEnabled(!imported);
copyPublicToClipboard.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
try {
PublicKey pk = pubkey.getPublicKey();
String openSSHPubkey = PubkeyUtils.convertToOpenSSHFormat(pk, pubkey.getNickname());
clipboard.setText(openSSHPubkey);
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
});
MenuItem copyPrivateToClipboard = menu.add(R.string.pubkey_copy_private);
copyPrivateToClipboard.setEnabled(!pubkey.isEncrypted() || imported);
copyPrivateToClipboard.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
try {
String data = null;
if (imported)
data = new String(pubkey.getPrivateKey());
else {
PrivateKey pk = PubkeyUtils.decodePrivate(pubkey.getPrivateKey(), pubkey.getType());
data = PubkeyUtils.exportPEM(pk, null);
}
clipboard.setText(data);
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
});
MenuItem changePassword = menu.add(R.string.pubkey_change_password);
changePassword.setEnabled(!imported);
changePassword.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
final View changePasswordView = inflater.inflate(R.layout.dia_changepassword, null, false);
((TableRow)changePasswordView.findViewById(R.id.old_password_prompt))
.setVisibility(pubkey.isEncrypted() ? View.VISIBLE : View.GONE);
new AlertDialog.Builder(PubkeyListActivity.this)
.setView(changePasswordView)
.setPositiveButton(R.string.button_change, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
String oldPassword = ((EditText)changePasswordView.findViewById(R.id.old_password)).getText().toString();
String password1 = ((EditText)changePasswordView.findViewById(R.id.password1)).getText().toString();
String password2 = ((EditText)changePasswordView.findViewById(R.id.password2)).getText().toString();
if (!password1.equals(password2)) {
new AlertDialog.Builder(PubkeyListActivity.this)
.setMessage(R.string.alert_passwords_do_not_match_msg)
.setPositiveButton(android.R.string.ok, null)
.create().show();
return;
}
try {
if (!pubkey.changePassword(oldPassword, password1))
new AlertDialog.Builder(PubkeyListActivity.this)
.setMessage(R.string.alert_wrong_password_msg)
.setPositiveButton(android.R.string.ok, null)
.create().show();
else {
pubkeydb.savePubkey(pubkey);
updateHandler.sendEmptyMessage(-1);
}
} catch (Exception e) {
Log.e(TAG, "Could not change private key password", e);
new AlertDialog.Builder(PubkeyListActivity.this)
.setMessage(R.string.alert_key_corrupted_msg)
.setPositiveButton(android.R.string.ok, null)
.create().show();
}
}
})
.setNegativeButton(android.R.string.cancel, null).create().show();
return true;
}
});
confirmUse = menu.add(R.string.pubkey_confirm_use);
confirmUse.setCheckable(true);
confirmUse.setChecked(pubkey.isConfirmUse());
confirmUse.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// toggle confirm use
pubkey.setConfirmUse(!pubkey.isConfirmUse());
pubkeydb.savePubkey(pubkey);
updateHandler.sendEmptyMessage(-1);
return true;
}
});
MenuItem delete = menu.add(R.string.pubkey_delete);
delete.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// prompt user to make sure they really want this
new AlertDialog.Builder(PubkeyListActivity.this)
.setMessage(getString(R.string.delete_message, pubkey.getNickname()))
.setPositiveButton(R.string.delete_pos, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
// dont forget to remove from in-memory
if(loaded)
bound.removeKey(pubkey.getNickname());
// delete from backend database and update gui
pubkeydb.deletePubkey(pubkey);
updateHandler.sendEmptyMessage(-1);
}
})
.setNegativeButton(R.string.delete_neg, null).create().show();
return true;
}
});
}
protected Handler updateHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
updateList();
}
};
protected void updateList() {
if (pubkeydb == null) return;
pubkeys = pubkeydb.allPubkeys();
PubkeyAdapter adapter = new PubkeyAdapter(this, pubkeys);
this.setListAdapter(adapter);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
super.onActivityResult(requestCode, resultCode, intent);
switch (requestCode) {
case REQUEST_CODE_PICK_FILE:
if (resultCode == RESULT_OK && intent != null) {
Uri uri = intent.getData();
try {
if (uri != null) {
readKeyFromFile(new File(URI.create(uri.toString())));
} else {
String filename = intent.getDataString();
if (filename != null)
readKeyFromFile(new File(URI.create(filename)));
}
} catch (IllegalArgumentException e) {
Log.e(TAG, "Couldn't read from picked file", e);
}
}
break;
}
}
/**
* @param name
*/
private void readKeyFromFile(File file) {
PubkeyBean pubkey = new PubkeyBean();
// find the exact file selected
pubkey.setNickname(file.getName());
if (file.length() > MAX_KEYFILE_SIZE) {
Toast.makeText(PubkeyListActivity.this,
R.string.pubkey_import_parse_problem,
Toast.LENGTH_LONG).show();
return;
}
// parse the actual key once to check if its encrypted
// then save original file contents into our database
try {
byte[] raw = readRaw(file);
String data = new String(raw);
if (data.startsWith(PubkeyUtils.PKCS8_START)) {
int start = data.indexOf(PubkeyUtils.PKCS8_START) + PubkeyUtils.PKCS8_START.length();
int end = data.indexOf(PubkeyUtils.PKCS8_END);
if (end > start) {
char[] encoded = data.substring(start, end - 1).toCharArray();
Log.d(TAG, "encoded: " + new String(encoded));
byte[] decoded = Base64.decode(encoded);
KeyPair kp = PubkeyUtils.recoverKeyPair(decoded);
pubkey.setType(kp.getPrivate().getAlgorithm());
pubkey.setPrivateKey(kp.getPrivate().getEncoded());
pubkey.setPublicKey(kp.getPublic().getEncoded());
} else {
Log.e(TAG, "Problem parsing PKCS#8 file; corrupt?");
Toast.makeText(PubkeyListActivity.this,
R.string.pubkey_import_parse_problem,
Toast.LENGTH_LONG).show();
}
} else {
PEMStructure struct = PEMDecoder.parsePEM(new String(raw).toCharArray());
pubkey.setEncrypted(PEMDecoder.isPEMEncrypted(struct));
pubkey.setType(PubkeyDatabase.KEY_TYPE_IMPORTED);
pubkey.setPrivateKey(raw);
}
// write new value into database
if (pubkeydb == null)
pubkeydb = new PubkeyDatabase(this);
pubkeydb.savePubkey(pubkey);
updateHandler.sendEmptyMessage(-1);
} catch(Exception e) {
Log.e(TAG, "Problem parsing imported private key", e);
Toast.makeText(PubkeyListActivity.this, R.string.pubkey_import_parse_problem, Toast.LENGTH_LONG).show();
}
}
/**
*
*/
private void pickFileSimple() {
// build list of all files in sdcard root
final File sdcard = Environment.getExternalStorageDirectory();
Log.d(TAG, sdcard.toString());
// Don't show a dialog if the SD card is completely absent.
final String state = Environment.getExternalStorageState();
if (!Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)
&& !Environment.MEDIA_MOUNTED.equals(state)) {
new AlertDialog.Builder(PubkeyListActivity.this)
.setMessage(R.string.alert_sdcard_absent)
.setNegativeButton(android.R.string.cancel, null).create().show();
return;
}
List<String> names = new LinkedList<String>();
{
File[] files = sdcard.listFiles();
if (files != null) {
for(File file : sdcard.listFiles()) {
if(file.isDirectory()) continue;
names.add(file.getName());
}
}
}
Collections.sort(names);
final String[] namesList = names.toArray(new String[] {});
Log.d(TAG, names.toString());
// prompt user to select any file from the sdcard root
new AlertDialog.Builder(PubkeyListActivity.this)
.setTitle(R.string.pubkey_list_pick)
.setItems(namesList, new OnClickListener() {
public void onClick(DialogInterface arg0, int arg1) {
String name = namesList[arg1];
readKeyFromFile(new File(sdcard, name));
}
})
.setNegativeButton(android.R.string.cancel, null).create().show();
}
class PubkeyAdapter extends ArrayAdapter<PubkeyBean> {
private List<PubkeyBean> pubkeys;
class ViewHolder {
public TextView nickname;
public TextView caption;
public ImageView icon;
}
public PubkeyAdapter(Context context, List<PubkeyBean> pubkeys) {
super(context, R.layout.item_pubkey, pubkeys);
this.pubkeys = pubkeys;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (convertView == null) {
convertView = inflater.inflate(R.layout.item_pubkey, null, false);
holder = new ViewHolder();
holder.nickname = (TextView) convertView.findViewById(android.R.id.text1);
holder.caption = (TextView) convertView.findViewById(android.R.id.text2);
holder.icon = (ImageView) convertView.findViewById(android.R.id.icon1);
convertView.setTag(holder);
} else
holder = (ViewHolder) convertView.getTag();
PubkeyBean pubkey = pubkeys.get(position);
holder.nickname.setText(pubkey.getNickname());
boolean imported = PubkeyDatabase.KEY_TYPE_IMPORTED.equals(pubkey.getType());
if (imported) {
try {
PEMStructure struct = PEMDecoder.parsePEM(new String(pubkey.getPrivateKey()).toCharArray());
String type = (struct.pemType == PEMDecoder.PEM_RSA_PRIVATE_KEY) ? "RSA" : "DSA";
holder.caption.setText(String.format("%s unknown-bit", type));
} catch (IOException e) {
Log.e(TAG, "Error decoding IMPORTED public key at " + pubkey.getId(), e);
}
} else {
try {
holder.caption.setText(pubkey.getDescription());
} catch (Exception e) {
Log.e(TAG, "Error decoding public key at " + pubkey.getId(), e);
holder.caption.setText(R.string.pubkey_unknown_format);
}
}
if (bound == null) {
holder.icon.setVisibility(View.GONE);
} else {
holder.icon.setVisibility(View.VISIBLE);
if (bound.isKeyLoaded(pubkey.getNickname()))
holder.icon.setImageState(new int[] { android.R.attr.state_checked }, true);
else
holder.icon.setImageState(new int[] { }, true);
}
return convertView;
}
}
}
| 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;
/**
* @author Kenny Root
*
*/
public class Colors {
public final static Integer[] defaults = new Integer[] {
0xff000000, // black
0xffcc0000, // red
0xff00cc00, // green
0xffcccc00, // brown
0xff0000cc, // blue
0xffcc00cc, // purple
0xff00cccc, // cyan
0xffcccccc, // light grey
0xff444444, // dark grey
0xffff4444, // light red
0xff44ff44, // light green
0xffffff44, // yellow
0xff4444ff, // light blue
0xffff44ff, // light purple
0xff44ffff, // light cyan
0xffffffff, // white
0xff000000, 0xff00005f, 0xff000087, 0xff0000af, 0xff0000d7,
0xff0000ff, 0xff005f00, 0xff005f5f, 0xff005f87, 0xff005faf,
0xff005fd7, 0xff005fff, 0xff008700, 0xff00875f, 0xff008787,
0xff0087af, 0xff0087d7, 0xff0087ff, 0xff00af00, 0xff00af5f,
0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff, 0xff00d700,
0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff,
0xff00ff00, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7,
0xff00ffff, 0xff5f0000, 0xff5f005f, 0xff5f0087, 0xff5f00af,
0xff5f00d7, 0xff5f00ff, 0xff5f5f00, 0xff5f5f5f, 0xff5f5f87,
0xff5f5faf, 0xff5f5fd7, 0xff5f5fff, 0xff5f8700, 0xff5f875f,
0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00,
0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff,
0xff5fd700, 0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7,
0xff5fd7ff, 0xff5fff00, 0xff5fff5f, 0xff5fff87, 0xff5fffaf,
0xff5fffd7, 0xff5fffff, 0xff870000, 0xff87005f, 0xff870087,
0xff8700af, 0xff8700d7, 0xff8700ff, 0xff875f00, 0xff875f5f,
0xff875f87, 0xff875faf, 0xff875fd7, 0xff875fff, 0xff878700,
0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7, 0xff8787ff,
0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7,
0xff87afff, 0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af,
0xff87d7d7, 0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87,
0xff87ffaf, 0xff87ffd7, 0xff87ffff, 0xffaf0000, 0xffaf005f,
0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00,
0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff,
0xffaf8700, 0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7,
0xffaf87ff, 0xffafaf00, 0xffafaf5f, 0xffafaf87, 0xffafafaf,
0xffafafd7, 0xffafafff, 0xffafd700, 0xffafd75f, 0xffafd787,
0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00, 0xffafff5f,
0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff, 0xffd70000,
0xffd7005f, 0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff,
0xffd75f00, 0xffd75f5f, 0xffd75f87, 0xffd75faf, 0xffd75fd7,
0xffd75fff, 0xffd78700, 0xffd7875f, 0xffd78787, 0xffd787af,
0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f, 0xffd7af87,
0xffd7afaf, 0xffd7afd7, 0xffd7afff, 0xffd7d700, 0xffd7d75f,
0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00,
0xffd7ff5f, 0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff,
0xffff0000, 0xffff005f, 0xffff0087, 0xffff00af, 0xffff00d7,
0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87, 0xffff5faf,
0xffff5fd7, 0xffff5fff, 0xffff8700, 0xffff875f, 0xffff8787,
0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f,
0xffffaf87, 0xffffafaf, 0xffffafd7, 0xffffafff, 0xffffd700,
0xffffd75f, 0xffffd787, 0xffffd7af, 0xffffd7d7, 0xffffd7ff,
0xffffff00, 0xffffff5f, 0xffffff87, 0xffffffaf, 0xffffffd7,
0xffffffff, 0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626,
0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858,
0xff626262, 0xff6c6c6c, 0xff767676, 0xff808080, 0xff8a8a8a,
0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffb2b2b2, 0xffbcbcbc,
0xffc6c6c6, 0xffd0d0d0, 0xffdadada, 0xffe4e4e4, 0xffeeeeee,
};
}
| Java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.