java telnet协议_Telnet协议的java实现

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 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 IAC SE

* @param type type of SB

* @param sbata byte array as

* @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(

" "

);

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(

""

);

reply = DONT;

break;

}

if(debug > 1)

System.out.println("");

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(

""

);

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(

""

);

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(

""

);

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); }

}

}