Telnet协议的java实现
//telnet.java
import java.net.Socket;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.awt.Dimension;
import java.util.Vector;
class TelnetIO
{
//0 is close, 1 is connet,2 is login
private String estring="";
private int isconn = 0;
public int timeout = 50000;
private String tmpmess="";
public String showe()
{
return estring;
}
public int nowstate()
{
return isconn;
}
public String showmess()
{
return tmpmess;
}
//login 1 is login,0 time out,-1 Exception,-2 passwd is error
public int login(String user,String passwd)
{
int error;
error=waits("ogin:");
if (error<1){return error;}
error=sends(user);
if (error<1){return error;}
error=waits("assword:");
if (error<1){return error;}
error=sends(passwd);
if (error<1){return error;}
error=waits("$");
if (error<1){return error;}
isconn=2;
return 1;
}
public int sends(String str)
{
byte[] buf = new byte[str.length()];
str.getBytes(0, str.length(), buf, 0);
try { send(buf); } catch(IOException e) {estring=e.toString();return -1;}
return 1;
}
public int waits(String prompt)
{
String tmp = "";
tmpmess=tmp;
int nt=1;
do {
try { tmp = new String(receive(), 0); }
catch(Exception e) { estring=e.toString();return -1; }
nt=nt+1;
if (nt>timeout){return 0; }
if (tmp.length()>0)
{
tmpmess=tmp;
// System.out.println("1");
// System.out.print(tmp);
}
if (prompt.equals("$") && (tmp.indexOf("Login incorrect")!=-1) )
{
estring="Login incorrect";
return -2;
}
} while(tmp.indexOf(prompt) == -1);
return 1;
}
public int waits( )
{
String tmp = "";
tmpmess=tmp;
int nt=1;
do {
try { tmp = new String(receive(), 0); }
catch(Exception e) { return -1; }
nt=nt+1;
if (nt>timeout){return 0; }
if (tmp.length()>0)
{ tmpmess=tmp;}
} while(tmp.length()==0);
return 1;
}
/**
* Debug level. This results in additional diagnostic messages on the
* java console.
*/
private static int debug = 0;
/**
* State variable for telnetnegotiation 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;
/**
* IAC - init sequence for telnet negotiation.
*/
private final static byte IAC = (byte)255;
/** FF
* [IAC] End Of Record
*/
private final static byte EOR = (byte)239;
/** EF
* [IAC] WILL
*/
private final static byte WILL = (byte)251;
/** FB
* [IAC] WONT
*/
private final static byte WONT = (byte)252;
/** FC
* [IAC] DO
*/
private final static byte DO = (byte)253;
/**FD
* [IAC] DONT
*/
private final static byte DONT = (byte)254;
/**FE
* [IAC] Sub Begin
*/
private final static byte SB = (byte)250;
/** FA
* [IAC] Sub End
*/
private final static byte SE = (byte)240;
/** FO
* Telnet option: echo text
*/
private final static byte TELOPT_ECHO = (byte)1; /* echo on/off */
/** 1
* Telnet option: End Of Record
*/
private final static byte TELOPT_EOR = (byte)25; /* end of record */
/** 19
* Telnet option: Negotiate About Window Size
*/
private final static byte TELOPT_NAWS = (byte)31; /* NA-WindowSize*/
/** 1F
* Telnet option: Terminal Type
*/
private final static byte TELOPT_TTYPE = (byte)24; /* terminal type */
//18
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 };
/**
* 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;
private Socket socket;
private BufferedInputStream is;
private BufferedOutputStream os;
// private StatusPeer peer = this; /* peer, notified on status */
/**
* Connect to the remote host at the specified port.
* @param address the symbolic host address
* @param port the numeric port
* @see #disconnect
*/
public void connect(String address, int port) throws IOException {
if(debug > 0) System.out.println("Telnet.connect("+address+","+port+")");
socket = new Socket(address, port);
is = new BufferedInputStream(socket.getInputStream());
os = new BufferedOutputStream(socket.getOutputStream());
neg_state = 0;
isconn=1;
receivedDX = new byte[256];
sentDX = new byte[256];
receivedWX = new byte[256];
sentWX = new byte[256];
}
/**
* Disconnect from remote host.
* @see #connect
*/
public void disconnect() throws IOException {
if(debug > 0) System.out.println("TelnetIO.disconnect()");
if(socket !=null) socket.close();
}
/**
* Connect to the remote host at the default telnet port (23).
* @param address the symbolic host address
*/
public void connect(String address) throws IOException {
connect(address, 23);
}
/**
* Set the object to be notified about current status.
* @param obj object to be notified.
*/
// public void setPeer(StatusPeer obj) { peer = obj; }
/** Returns bytes available to be read. Since they haven't been
* negotiated over, this could be misleading.
* Most useful as a boolean value - "are any bytes available" -
* rather than as an exact count of "how many ara available."
*
* @exception IOException on problems with the socket connection
*/
public int available() throws IOException
{
return is.available();
}
/**
* Read data from the remote host. Blocks until data is available.
* Returns an array of bytes.
* @see #send
*/
public byte[] receive() throws IOException {
int count = is.available();
byte buf[] = new byte[count];
count = is.read(buf);
if(count < 0) throw new IOException("Connection closed.");
if(debug > 1) System.out.println("TelnetIO.receive(): read bytes: "+count);
buf = negotiate(buf, count);
return buf;
}
/**
* Send data to the remote host.
* @param buf array of bytes to send
* @see #receive
*/
public void send(byte[] buf) throws IOException {
if(debug > 1) System.out.println("TelnetIO.send("+buf+")");
os.write(buf);
os.flush();
}
public void send(byte b) throws IOException {
if(debug > 1) System.out.println("TelnetIO.send("+b+")");
os.write(b);
os.flush();
}
/**
* Handle an incoming IAC SB <type> <bytes> IAC SE
* @param type type of SB
* @param sbata byte array as <bytes>
* @param sbcount nr of bytes. may be 0 too.
*/
private void handle_sb(byte type, byte[] sbdata, int sbcount)
throws IOException
{
if(debug > 1)
System.out.println("TelnetIO.handle_sb("+type+")");
switch (type) {
case TELOPT_TTYPE:
if (sbcount>0 && sbdata[0]==TELQUAL_SEND) {
String ttype;
send(IACSB);send(TELOPT_TTYPE);send(TELQUAL_IS);
/* FIXME: need more logic here if we use
* more than one terminal type
*/
Vector vec = new Vector(2);
vec.addElement("TTYPE");
ttype=null;
if(ttype == null) ttype = "dumb";
byte[] bttype = new byte[ttype.length()];
ttype.getBytes(0,ttype.length(), bttype, 0);
send(bttype);
send(IACSE);
}
}
}
/**
* Notify about current telnet status. This method is called top-down.
* @param status contains status information
*/
public Object notifyStatus(Vector status) {
if(debug > 0)
System.out.println("TelnetIO.notifyStatus("+status+")");
isconn=0;
return null;
}
/* wo faengt buf an bei buf[0] oder bei buf[1] */
private byte[] negotiate(byte buf[], int count) throws IOException {
if(debug > 1)
System.out.println("TelnetIO.negotiate("+buf+","+count+")");
byte nbuf[] = new byte[count];
byte sbbuf[] = new byte[count];
byte sendbuf[] = new byte[3];
byte b,reply;
int sbcount = 0;
int boffset = 0, noffset = 0;
Vector vec = new Vector(2);
while(boffset < count) {
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)((int)b-256);
switch (neg_state) {
case STATE_DATA:
if (b==IAC) {
neg_state = STATE_IAC;
} else {
nbuf[noffset++]=b;
}
break;
case STATE_IAC:
switch (b) {
case IAC:
if(debug > 2)
System.out.print("IAC ");
neg_state = STATE_DATA;
nbuf[noffset++]=IAC;
break;
case WILL:
if(debug > 2)
System.out.print("WILL ");
neg_state = STATE_IACWILL;
break;
case WONT:
if(debug > 2)
System.out.print("WONT ");
neg_state = STATE_IACWONT;
break;
case DONT:
if(debug > 2)
System.out.print("DONT ");
neg_state = STATE_IACDONT;
break;
case DO:
if(debug > 2)
System.out.print("DO ");
neg_state = STATE_IACDO;
break;
case EOR:
if(debug > 2)
System.out.print("EOR ");
neg_state = STATE_DATA;
break;
case SB:
if(debug > 2)
System.out.print("SB ");
neg_state = STATE_IACSB;
sbcount = 0;
break;
default:
if(debug > 2)
System.out.print(
"<UNKNOWN "+b+" > "
);
neg_state = STATE_DATA;
break;
}
break;
case STATE_IACWILL:
switch(b) {
case TELOPT_ECHO:
if(debug > 2)
System.out.println("ECHO");
reply = DO;
vec = new Vector(2);
vec.addElement("NOLOCALECHO");
// peer.notifyStatus(vec);
break;
case TELOPT_EOR:
if(debug > 2)
System.out.println("EOR");
reply = DO;
break;
default:
if(debug > 2)
System.out.println(
"<UNKNOWN,"+b+">"
);
reply = DONT;
break;
}
if(debug > 1)
System.out.println("<"+b+", WILL ="+WILL+">");
if ( reply != sentDX[b+128] ||
WILL != receivedWX[b+128]
) {
sendbuf[0]=IAC;
sendbuf[1]=reply;
sendbuf[2]=b;
send(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.out.println("ECHO");
vec = new Vector(2);
// vec.addElement("LOCALECHO");
reply = DONT;
break;
case TELOPT_EOR:
if(debug > 2)
System.out.println("EOR");
reply = DONT;
break;
default:
if(debug > 2)
System.out.println(
"<UNKNOWN,"+b+">"
);
reply = DONT;
break;
}
if ( reply != sentDX[b+128] ||
WONT != receivedWX[b+128]
) {
sendbuf[0]=IAC;
sendbuf[1]=reply;
sendbuf[2]=b;
send(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.out.println("ECHO");
reply = WILL;
vec = new Vector(2);
vec.addElement("LOCALECHO");
// peer.notifyStatus(vec);
break;
case TELOPT_TTYPE:
if(debug > 2)
System.out.println("TTYPE");
reply = WILL;
break;
case TELOPT_NAWS:
if(debug > 2)
System.out.println("NAWS");
vec = new Vector(2);
vec.addElement("NAWS");
//******************************************************
// Dimension size = (Dimension)
// peer.notifyStatus(vec);
receivedDX[b] = DO;
Dimension size=null;
if(size == null)
{
/* this shouldn't happen */
send(IAC);
send(WONT);
send(TELOPT_NAWS);
reply = WONT;
sentWX[b] = WONT;
break;
}
reply = WILL;
sentWX[b] = WILL;
sendbuf[0]=IAC;
sendbuf[1]=WILL;
sendbuf[2]=TELOPT_NAWS;
send(sendbuf);
send(IAC);send(SB);send(TELOPT_NAWS);
send((byte) (size.width >> 8));
send((byte) (size.width & 0xff));
send((byte) (size.height >> 8));
send((byte) (size.height & 0xff));
send(IAC);send(SE);
break;
default:
if(debug > 2)
System.out.println(
"<UNKNOWN,"+b+">"
);
reply = WONT;
break;
}
if ( reply != sentWX[128+b] ||
DO != receivedDX[128+b]
) {
sendbuf[0]=IAC;
sendbuf[1]=reply;
sendbuf[2]=b;
send(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.out.println("ECHO");
reply = WONT;
vec = new Vector(2);
vec.addElement("NOLOCALECHO");
// peer.notifyStatus(vec);
break;
case TELOPT_NAWS:
if(debug > 2)
System.out.println("NAWS");
reply = WONT;
break;
default:
if(debug > 2)
System.out.println(
"<UNKNOWN,"+b+">"
);
reply = WONT;
break;
}
if ( reply != sentWX[b+128] ||
DONT != receivedDX[b+128]
) {
send(IAC);send(reply);send(b);
sentWX[b+128] = reply;
receivedDX[b+128] = DONT;
}
neg_state = STATE_DATA;
break;
case STATE_IACSBIAC:
if(debug > 2) System.out.println(""+b+" ");
if (b == IAC) {
sbcount = 0;
current_sb = b;
neg_state = STATE_IACSBDATA;
} else {
System.out.println("(bad) "+b+" ");
neg_state = STATE_DATA;
}
break;
case STATE_IACSB:
if(debug > 2) System.out.println(""+b+" ");
switch (b) {
case IAC:
neg_state = STATE_IACSBIAC;
break;
default:
current_sb = b;
sbcount = 0;
neg_state = STATE_IACSBDATA;
break;
}
break;
case STATE_IACSBDATA:
if (debug > 2) System.out.println(""+b+" ");
switch (b) {
case IAC:
neg_state = STATE_IACSBDATAIAC;
break;
default:
sbbuf[sbcount++] = b;
break;
}
break;
case STATE_IACSBDATAIAC:
if (debug > 2) System.out.println(""+b+" ");
switch (b) {
case IAC:
neg_state = STATE_IACSBDATA;
sbbuf[sbcount++] = IAC;
break;
case SE:
handle_sb(current_sb,sbbuf,sbcount);
current_sb = 0;
neg_state = STATE_DATA;
break;
case SB:
handle_sb(current_sb,sbbuf,sbcount);
neg_state = STATE_IACSB;
break;
default:
neg_state = STATE_DATA;
break;
}
break;
default:
if (debug > 2)
System.out.println(
"This should not happen: "+
neg_state+" "
);
neg_state = STATE_DATA;
break;
}
}
buf = new byte[noffset];
System.arraycopy(nbuf, 0, buf, 0, noffset);
return buf;
}
}
class Telnet2
{
public static void main(String args[])
{
TelnetIO tio = new TelnetIO();
int nnn;
try {
tio.connect("59.64.156.145");//在此输入欲登陆的主机名
nnn=tio.login("test\r","test\r");//用户名和密码
if (nnn!=1)
{
System.out.println("error login ");
return ;
}
System.out.print(tio.showmess());
tio.sends("ls\r");
do
{ nnn=tio.waits();
if (nnn==1){System.out.print(tio.showmess());}
}while (nnn==1);
tio.sends("rm ss\r");
do
{ nnn=tio.waits();
if (nnn==1){System.out.print(tio.showmess());}
}while (nnn==1);
} catch(IOException e) { System.out.println(e); }
}
}